原文链接 https://www.cnblogs.com/StevenHuSir/p/Java_ArrayAndSet.html
Java-数组和集合简单使用
数组和集合：
1.数组第一种定义方式
int[] counts = {1,2,3,4,5};
2.数组第二种定义方式(先初始化，后赋值)
int[] numbers = new int[3];
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[0] = 1000;//在索引范围以内可以更改
3.数组创建第三种方式
int[] nums = new int[] {1,2,3};
//修改
nums[0] = 1000;
复制代码
package com.steven.demo;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
//java的八种数据类型
//byte int long short -整型
//float double -浮点型
//boolean -布尔型
//char 字符型
int i = 1000;
long l = 1000;
float f = l;
System.out.println("Hello, world ~" + l + i + f);
char c = 'A';
System.out.println(c);
char a = 'a';
char zero = '0';
System.out.println("a===" + a);
System.out.println("zero = " + zero);
//1.数组第一种定义方式
int[] counts = {1,2,3,4,5};
//获取数组的第一个值 syso 打印快捷键
System.out.println("数组的第一个值是" + counts[0]);//数组的第一个值是1
//获取数组的最后一个值
int length = counts.length;
System.out.println("数组的长度是"+length);//数组的长度是5
System.out.println("数组的最后一个元素" + counts[length-1]);//数组的最后一个元素5
float[] moneys = {1.5f,2.0f,3.0f};
char[] cs = {'A','中','1','C'};
System.out.println("浮点型数组"+moneys[1]);//2.0
System.out.println("字符型数组"+cs[1]);//中
//2.数组第二种定义方式(先初始化，后赋值)
//int[] numbers = {};
//Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
//at com.steven.demo.Test.main(Test.java:39)
int[] numbers = new int[3];
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[0] = 1000;//在索引范围以内可以更改
//numbers[3] = 4;//Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
System.out.println("numbers = " + numbers.length);//numbers = 3
//数组一旦定义长度就不可以更改了
//3.数组如何获取值-for循环获取值
for (int j = 0; j < numbers.length; j++) {
System.out.println("j==" + j);
//j==0
//j==1
//j==2
}
int k = 0;
for (int b : numbers) {
System.out.println("numbers["+k+"]"+b);
k++;
//numbers[0]1000
//numbers[1]2
//numbers[2]3
}
//4.数组创建第三种方式
int[] nums = new int[] {1,2,3};
//修改
nums[0] = 1000;
System.out.println(nums[0]);
System.out.println(nums.length);
//5.冒泡排序
int[] ks = {1,3,34,56,78,33,3,56};
for (int j = 0; j < ks.length; j++) {
for (int b = 1; b < ks.length-1; b++) {
System.out.println(ks[j]+"===="+ks[b]);
}
System.out.println("==============");
}
//6.动态数组
//java.util.Collection
//collection接口 --- list接口-- 一个动态数组
//jdk里面的ArrayList和Vectory是动态数组
//集合条件元素是调用:add(object);
List<String> strings = new ArrayList<String>(); //等价于String[] str = new String[100];
strings.add("1");
strings.add("2");
strings.add("3");
strings.add("4");//添加到这一行：数组的长度编程9
System.out.println("动态数组"+strings.size() + strings.getClass());//动态数组4class java.util.ArrayList
//获取元素的第一个值
System.out.println("元素的第一个值"+strings.get(0));//元素的第一个值1
System.out.println("元素的最后一个值"+strings.get(strings.size()-1));//元素的最后一个值4
//修改
strings.set(0, "1000");
System.out.println("元素的第一个值是"+strings.get(0));//元素的第一个值是1000
//删除
strings.remove(2);
//可以赋值为空吗？
strings.set(0, null);
strings.add(null);
System.out.println("可以赋值为空吗？"+strings.get(0));
//取值
//a.第一种 for each循环
for (String string: strings) {
System.out.println("string = " + string);
//string = 1000
//string = 2
//string = 4
}
//b.第二种 for循环
for (int j = 0; j < strings.size(); j++) {
System.out.println(strings.get(j));
}
//c.第三种 迭代器
Iterator<String> inerator = strings.iterator();
while (inerator.hasNext()) {
System.out.println(inerator.next());
}
}
}
复制代码
复制代码
package com.steven.demo;
import java.util.ArrayList;
import java.util.Iterator;//迭代器
import java.util.List;
public class Test {
public static void main(String[] args) {
//1.数组是一种数据的集合
//2.数组作为一种引用类型
//3.数组是一种容器，可以用来存储其他任意类型的元素
//4.数组元素的类型可以是基本类型，也可以是引用类型，但同一个数组只能是同一种类型
//5.数组的长度在在数组创建后就确定了，就无法修改了
//6.数组分为：一维数组，二维数组，三维数组，多维数组
//一、声明数组语法
/*
1>.数组元素的类型[] 变量名称
2>.数组元素的类型 变量名称[]
数组元素的类型，可以使java中的任一类型，变量名称可以是任意合法的标识符
例：
int[] a;
Student[] students;
在一行中也可以声明多个数组, 例: int[] a,b,c
* */
//声明一个一维数组，用来存储int类型
int[] i = {1,2,3};
//boolean 类型数组
boolean [] j = {true,false,true,false};
//String类型数组
String[] strings = {"Steven","HuSir"};
//byte数组
byte[] k = {1,2,3};
//char数组
char[] m = {'a','b'};
//Object数组
Object object1 = new Object();
Object object2 = new Object();
Object[] objects = {object1,object2};
//数组创建两种方式
//第一种: 使用new 操作符来创建数组
//格式为：new 数组元素的数据类型 [数组元素的个数]
//基本类型的数组和引用类型的数组，必须清楚数组为引用类型，它在堆中分配。
//声明一个int类型的数组，数组长度为3
int[] data = new int[3];
//给数组中的元素赋值,如果不赋值默认为该类型的默认值，如果是int类型就为0；
//赋值：变量名[下标] 下标从0开始
data[0] = 1;
data[1] = 2;
data[2] = 3;
for (int i1= 0; i1 < data.length; i1++) {
System.out.println("下标为："+i1+"的值为："+data[i1]);
//下标为：0的值为：1
//下标为：1的值为：2
//下标为：2的值为：3
}
}
}
复制代码
数组动态初始化和静态初始化的选择：
//什么时候使用动态初始化,什么时候使用静态初始化?
//1.无论静态初始化还是动态初始化,最终的内存分布都是一样的如果在创建数组的时候,知道数组中应该存储什么数据,这个时候当然采用静态初始化方式
//2.如果在创建数组时,无法预测到数组中的存储什么数据,只是先开辟空间,就是用动态初始化的方式进行创建
二维数组和多维数组以及冒泡排序
复制代码
package com.steven.demo;
public class ArrayTest {
public static void main(String[] args) {
Student students = new Student();
//二维数组的声明和使用
//二维数组属于多维数组，什么是多维数组，当数组元素的类型是数组时就成了多维数组
//二维数组的声明格式
//1.数组元素的数据类型[][] 变量名
//2.数组元素的数据类型 变量名 [][]
//其中中括号的个数就是数组的维数
//3.特殊的一维数组，(这个一维数组中每个元素都是一维数组)
//1.声明一个二维数组
int [][] m = new int[2][3];
//对二维数组赋值
m[0][0] = 1;
m[0][1] = 2;
m[0][2] = 3;
m[1][0] = 4;
m[1][1] = 5;
m[1][2] = 6;
//输出二维数组
for (int i = 0; i < m.length; i++) {
for (int j = 0; j < m[i].length; j++) {
System.out.println("输出二维数组" + m[i][j]);
}
}
//2.二维数组的动态初始化
//3个一维数组，每个一维数组中有四个元素
int[][] a = new int [3][4];
a[1][2] = 1000;
//遍历
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.println(a[i][j] + " ");
}
System.out.print("
");
}
//3.多维数组: 当数组元素的类型是数组时就成了多维数组
int[][]n = new int[][] {{1,2,3},{4,5,6},{7,8,9}};
//循环三次
for (int i = 0; i < n.length; i++) {
for (int j = 0; j < n[i].length; j++) {
System.out.println(n[i][j]+ " ");
}
System.out.print("
");
}
//4.冒泡排序
int[] array = {3,1,6,2,5};
System.out.println("数组的长度为"+array.length);
//开始排序
for (int i = array.length-1; i >0; i--) {
for (int j = 0; j < i; j++) {
if (array[j] > array[j+1]) {
//交换位置
int temp;
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
//遍历
for (int i = 0; i < array.length; i++) {
System.out.println("数组元素为"+array[i]);
}
}
}