声明和使用数组

一、数组：用于批量保存一类数据。是引用数据类型之一。

//变量的格式： 数据类型 变量名 = 值;

int i = 10;

int j;

j = 20;

1.声明一个数组

int[] scores;

String[] names;

Person[] persons;

2.为数组初始化并赋值

①静态初始化：初始化操作和赋值操作同时进行

scores = new int[]{1,2,3,4,5};

②动态初始化：初始化操作和赋值操作分开进行

names = new String[3];

names[0] = "张三";

names[1] = "李四";

names[2] = "王五";

persons = new Person[3];

persons[0] = new Person();

persons[1] = new Person("张三", 18);

persons[2] = new Person("李四", 20);

二、数组的遍历

/*int s1 = scores[0];

System.out.println(s1);

System.out.println(scores[1]);

System.out.println(scores[2]);

System.out.println(scores[3]);

System.out.println(scores[4]);*/

1. 普通 for 循环遍历数组

for(int i = 0; i < scores.length; i++){

int s1 = scores[i];

System.out.println(s1);

}

for(int i = 0; i < persons.length; i++){

Person p = persons[i];

System.out.println(p.say());

}

2. 增强 for 循环遍历数组

for(被遍历数组中元素的数据类型 变量名 : 被遍历的数组){

}

for(int score : scores){

System.out.println(score);

}

for(Person p : persons){

System.out.println(p.say());

}

3. 普通 for 循环与增强 for 循环的区别？

//需求：

for(int i = 0; i < scores.length; i++){

if(scores[i] == 2){

scores[i] = 22;

}

}

for(int s1 : scores){

if(s1 == 2){

s1 = 22; //该的是变量 s1 的值，与数组没有关系

}

}

三、数组的特点：

①数组无论静态初始化还是动态初始化必须指明长度

②数组中每个元素的位置都有索引值(下角标 、 下标)， 索引值从 0 开始， 到 数组的长度 - 1

③获取数组长度的属性： length

四、数组的常见异常

int[] arr = new int[3];

arr[-4] = 22; //数组越界异常：ArrayIndexOutOfBoundsException

Person persons = new Person[3]; //{null, new Person("张三", 18), new Person("李四", 20)}

persons[1] = new Person("张三", 18);

persons[2] = new Person("李四", 20);

for(Person p : persons){

System.out.println(p.say());//null.say(); 空指针异常： NullPointerException

}

五、数组的默认值

基本数据类型：

byte short int ---> 0

long ---> 0L

float ---> 0.0F

double ---> 0.0D

char ---> '\u0000'

boolean ---> false

引用数据类型： ---> null

|-- 类（class）

|-- 接口（interface）

|-- 数组（[]）

六、、二维数组

1. 声明一个二维数组

int[][] arr;

2. 为二维数组初始化并赋值

①静态初始化：

arr = new int[][]{ {1,2,3}, {4,5,6}, {7,8} };

②动态初始化：

方式一:

arr = new int[5][6]; //{ {0,0,55,0,0,0},{0,0,0,0,0,0},{0,6,0,0,0,0},{0,0,0,0,0,0}{0,0,0,0,0,0} }

arr[0][2] = 55;

arr[2][1] = 6;

方式二：

arr{ {0}, {0,0}, {0,5,0}, {0,0,0,0}, {0,0,0,0,0}}

arr[0] = new int[1];

arr[1] = new int[2];

arr[2] = new int[3];

arr[3] = new int[4];

arr[4] = new int[5];

arr[2][1] = 5;

3. 二维数组的遍历

for(int i = 0; i < arr.length; i++){

int[] as = arr[i];

for(int j = 0; j < as.length; j++){

int a = as[j];

System.out.print(a + "\t");

}

System.out.println();

}

for(int i = 0; i < arr.length; i++){

for(int j = 0; j < arr[i].length; j++){

System.out.print(arr[i][j] + "\t");

}

System.out.println();

}

for(int[] as : arr){

for(int a : as){

System.out.print(a + "\t");

}

System.out.println();

}

一、命令行参数：

public static void main(String[] args){

/*for(int i = 0; i < args.length; i++){

String str = args[i];

System.out.println(str);

}*/

String str = args[0];

//将 String 类型转换成 int

int num = Integer.parseInt(str);

}

通过执行 java 命令传递参数： java HelloWorld aaa bbb ccc

一、可变参数：

①可变参数不能与数组参数之间构成重载

②可变参数必须写在当前参数列表的末尾

//需求：计算两个整数的和

/*public int add(int a, int b){

return a + b;

}

//需求：计算三个整数的和

public int add(int a, int b, int c){

return a + b + c;

}*/

public static void main(String[] args){

int[] arr = new int[]{1,2,3,4,5};

//int sum = add(arr);

int sum = add(1,2,3,4,5,6,7,7,6,5); //调用可变参数的方法

add(arr);

}

/*public static int add(int[] arr){

int sum = 0;

for(int i = 0; i < arr.length; i++){

sum += arr[i];

}

return sum;

}*/

public static int add(int ... args){//可变参数：可以接收 0 个或 多个的 int 类型的数据

int sum = 0;

for(int i = 0; i < args.length; i++){

sum += args[i];

}

return sum;

}

public static int add(String str, double ... args){

}

public static int add(Person ... persons){

}