数组：存储多个数据
定义：相同数据类型的有序集合，一段连续的空间。每一个数据称作一个数组元素，每个数组元素可以通过下标来访问它们。
特点：1.数组变量是引用数据类型，数组也可以看成是对象，数组中的每一个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中。
2.长度一旦确定不可改变。数组一旦被创建，它的大小就是不可以改变的。
3.可以存储任意数据类型，但多个数据要求数据类型一致
4.数组是有序的
索引|下标：
第一个空间：0
最后一个空间：数组名.length-1
数组的长度：
数组名.length
操作数组中的数据：
数组名[索引|下标]->确定数组中的某一块空间操作空间中的数据内容。
结构：
数组的声明：就是在声明一个数组类型的变量，变量中并不存在任何数据。
声明的时候，并不为数组分配内存空间，只有使用new之后才为它分配空间。
数据类型[] 数组名；--> 这种最规范
数据类型 数组名[];
数组的初始化：
动态初始化：先创建数组对象，然后赋值
数据类型[] 数组名 = new 数据类型[长度];
数据类型：数组存放的数据类型为任意数据类型
不同数据类型的数组每一个空间存在一个默认值：
整数：0 小数：0.0 布尔： false 字符：空字符 引用：null
静态初始化：创建数组对象同时赋值
数据类型[] 数组名 = new 数据类型[]{值1,值2.....}
数据类型[] 数组名 = {值1.......};
注意：ArrayIndexOutOfBoundsException 数组索引下标异常
数组的打印：
数组是引用类型，遵循引用类型的内存模型规则，直接打印时调用 toString() 方法，未经过重写则调用的是Object的方法，打印的只是数组的地址。 想要打印内容需要使用Arrays工具类提供的 toString() 方法。
数组的拷贝：
Arrays工具类中提供了一系列 public static Object[] copyOf(Object[] original, int newLength) 的方法，可以拷贝原数组中指定长度的元素到一个新的数组并返回。 public static Object[] copyOfRange(Object[] original, int from, int to) 还可以指定起 始位置和截止位置。 System类里也包含了一个 static void arraycopy（object src，int srcpos，object dest， int destpos，int length） 方法，该方法可以将src数组里的元素值赋给dest数组的元素，其中 srcpos指定从src数组的第几个元素开始赋值，length参数指定将src数组的多少个元素赋给dest数组的 元素。
public class Class001_Array {
public static void main(String[] args) {
// 声明
int[] arr1;
double arr2[];
//动态初始化
arr1 = new int[3];
arr2 = new double[5];
//为数组赋值
arr1[0] = 100;
arr1[1] = 101;
arr1[2] = 102;
//获取数组中的数据
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
//静态初始化
String[] arr3 = new String[]{"张三","李四","王五","赵六"};
System.out.println(arr3[0]);
System.out.println(arr3[1]);
System.out.println(arr3[2]);
System.out.println(arr3[3]);
char[] arr4 = {'a','b','c'};
System.out.println(arr4[0]);
System.out.println(arr4[1]);
System.out.println(arr4[2]);
System.out.println(arr4.length);
/*数组中的最后一个数据*/
System.out.println(arr4[arr4.length-1]);
}
}
存储引用数据类型的数组：
public class Class002_Array {
public static void main(String[] args) {
//数据类型[] 数组名 = new 数据类型[长度];
int[] arr = {1,2,3,4};
//构建一个存储学生数据的数组
Student[] stus = new Student[3];
//学生数据
Student s1 = new Student("张三",18);
Student s2 = new Student("李四",19);
Student s3 = new Student("王五",17);
//把学生数据放入数组
stus[0] = s1;
stus[1] = s2;
stus[2] = s3;
System.out.println(stus);
System.out.println(stus[0]);
System.out.println(stus[1]);
System.out.println(stus[2]);
}
}
//学生类
public class Student{
//成员: 类中方法外
//1.属性: 特点特征
private String name;
private int age;
//构造器
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//功能:
public void study(){
System.out.println("学习");
}
}
数组的遍历：
1.普通for循环：操作索引，索引控制变化情况
2.增强for循环|for each 只能从前往后遍历
for(数据类型 变量名i: 数组名|集合名){
每一次循环i代表数组中的每一个数据
}
public class Class003_Each {
public static void main(String[] args) {
int[] arr = {1,2,3,4};
//普通for循环
//变量控制数组的索引
for(int i=0;i<=arr.length-1;i++){
System.out.println(arr[i]);
}
//增强for循环
for(int i:arr){
System.out.println(i);
}
}
}
二维数组：
声明：
数据类型 [] [] 数组名; -->推荐
数组类型 数组名 [] [];
数组类型 [] 数组名 [] ;
数据类型 [] [] 数组名;
初始化：
动态初始化：先创建数组在赋值
数据类型[] [] 数组名 = new 数据类型[外层的二维的长度] [内存的一维长度];
特点: 内存的每一个一维数组长度相同
数据类型 [] [] 数组名 = new 数据类型[外层的二维的长度] [];
特点：内存的每一个一维数组没有构建，长度由构建的时候指定。
内层的每一个一维数组的创建按照一维数组的创建方式(动态，静态)
静态初始化：创建数组的同时赋值
数据类型 [] [] 数组名 = new 数据类型[] [] {{值1,值2....},{值1,值2,值3....},{值1,值2,值3....}}
数据类型 [] [] 数组名 = {{值1,值2....},{值1,值2,值3....},{值1,值2,值3....}};
操作二维数组中的数据：
数组名[外层二维索引] [内层一维索引]
public class Class001_Array {
public static void main(String[] args) {
//动态
//数据类型[][] 数组名 = new 数据类型[外层的二维的长度][内层的一维的长度];
int[][] arr1 = new int[2][3];
//赋值
arr1[0][0] = 1;
arr1[0][1] = 2;
arr1[0][2] = 3;
arr1[1][0] = 4;
arr1[1][1] = 5;
arr1[1][2] = 6;
System.out.println(arr1[0][0]);
System.out.println(arr1[0][1]);
System.out.println(arr1[0][2]);
System.out.println(arr1[1][0]);
System.out.println(arr1[1][1]);
System.out.println(arr1[1][2]);
//数据类型[][] 数组名 = new 数据类型[外层的二维的长度][];
double arr2[][] = new double[2][];
//构建每一个一维数组
arr2[0] = new double[3];
arr2[0][0] = 1.1;
arr2[0][1] = 2.2;
arr2[0][2] = 3.3;
arr2[1] = new double[]{3.3,4.4};
System.out.println(arr2[0][0]);
System.out.println(arr2[0][1]);
System.out.println(arr2[0][2]);
System.out.println(arr2[1][0]);
System.out.println(arr2[1][1]);
//静态初始化
char[][] arr3 = new char[][]{{'a'},{'b','c'},{'d','e','f'}};
System.out.println(arr3[0][0]);
System.out.println(arr3[1][0]);
System.out.println(arr3[1][1]);
System.out.println(arr3[2][0]);
System.out.println(arr3[2][1]);
System.out.println(arr3[2][2]);
System.out.println(arr3.length);
}
}
二维数组的遍历方式：
1.普通嵌套增强
2.普通嵌套普通
3.增强嵌套普通
4.增强嵌套增强
public class Class002_Array {
public static void main(String[] args) {
//静态初始化
char[][] arr = new char[][]{{'a'},{'b','c'},{'d','e','f'}};
//1)普通嵌套增强
for(int i = 0;i<arr.length;i++){
for(char ch:arr[i]){
System.out.println(ch);
}
}
//3. 增强嵌套增强
for(char[] chars:arr){
for(char ch:chars){
System.out.println(ch);
}
}
}
}
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
