Java常见的语法错误有哪些 java语法总结

文章目录

• 对Java平台的理解
• 一、使用记事本编写helloworld程序
• 二、配置环境变量
• 三、Java基础知识

• 标识符
• 数据类型
• 常量
• 变量
• Java中的基本类型
• 常量与类型
• 定义变量
• 数据类型转换

• 自动转换
• 强制转换

• 运算符

• 算术运算符
• 赋值运算符
• 比较运算符
• 逻辑运算符
• 三元运算符
• 运算符优先级

• 引用数据类型

• Scanner类
• 随机数类Random

• 流程控制语句

• 选择结构if—else
• 循环语句while
• 循环语句for
• 循环语句do...while
• switch循环

• 数组

• JVM的内存划分
• 数组的定义
• 遍历数组
• 获取数组元素最值

• 二维数组

• 数组常见异常

• ASCII码

• Char类型的存储

• 四、Java基础语法

• 方法

• 方法的重载
• 重载的注意事项
• 参数传递

• 基本数据类型传参
• 引用数据类型传参

• 引用数据类型（类）

• 类的定义与使用

• ArrayList集合

• 集合的创建
• ArraayList方法补充

---

对Java平台的理解

Java本身是一种面向对象的语言，最显著的特性有两个方面，一是所谓的“书写一次，到处运行”（Write once, run anywhere），能够非常容易地获得跨平台能力；另外就是垃圾收集（GC, Garbage Collection），Java 通过垃圾收集器（Garbage Collector）回收分配内存，大部分情况下，程序员不需要自己操心内存的分配和回收。

• JDK与JRE的关系

JRE，也就是 Java 运行环境，包含了 JVM 和 Java 类库，以及一些模块等。
JDK 它是Java开发运行环境，可以看作是 JRE 的一个超集，提供了更多工具，比如编译器、各种诊断工具等。
( 实现跨平台需要依赖Java的虚拟机 JVM )

• 对于“Java 是解释执行”这句话，这个说法不太准确。

我们开发的 Java 的源代码，首先通过 Javac 编译成为字节码（bytecode），然后，在运行时，通过 Java 虚拟机（JVM）内嵌的解释器将字节码转换成为最终的机器码。但是常见的 JVM，比如我们大多数情况使用的 Oracle JDK 提供的 Hotspot JVM，都提供了 JIT（Just-In-Time）编译器，也就是通常所说的动态编译器，JIT 能够在运行时将热点代码编译成机器码，这种情况下部分热点代码就属于编译执行，而不是解释执行了。

---

一、使用记事本编写helloworld程序

Java代码的编写执行过程
a: 源文件：编写Java源文件（我们也称之为源代码文件），它的扩展名为.java；
b: 编译：然后通过编译器把源文件编译成字节码文件，字节码文件扩展名为.class；
c: 运行：最后使用解释器来运行字节码文件。

二、配置环境变量

环境变量的作用：让Java的bin目录下的javac命令可以在任意目录下执行

三、Java基础知识

标识符

定义：就是给类,接口,方法,变量等起名字时使用的字符序列
组成规则(只能包含下面的内容,不能有其它内容)
1: 英文大小写字母
*2：数字字符
3：$和_
c: 注意事项
1：数字不能开头
2：不可以使用关键字
3：严格区分大小写，不限制长度
*4：起名时，尽量达到见名知意
标识符中常见的命名规则(这些规定是不受语法约束的)
a: 包名：多单词组成时所有字母均小写，使用.连接 aaa.bbb.ccc
b: 类名&接口名：大驼峰式 AaaBbbCcc
c: 变量名&方法名：小驼峰式 aaaBbbCcc
d: 常量名：多单词组成是所有字母均大写，使用_连接AAA_BBB_CCC

数据类型

Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型
Java中数据类型的分类
基本数据类型:
基本数据类型是Java语言中内置的类型，分别是整数类型、小数类型、字符类型、布尔类型。
整数(byte、short、int、long)、小数(float、double)、字符类型(char)、布尔类型(boolean)
引用数据类型:
是强大的数据类型，它是基于基本数据类型创建的。
JavaSE中提供了一个超级类库，类库中包含了近万种引用数据类型。
字符串“String”属于引用类型

常量

常量就是不变的数据量, 在程序执行的过程中其值不可以发生改变

变量

什么是变量?
变量是一个内存中的小盒子（小容器）
变量是内存中装载数据的小盒子，你只能用它来存数据和取数据。
结论：变量必须要有明确的类型，什么类型的变量装载什么类型的数据。

Java中的基本类型

Java中基本类型一共4类，把这4类展开后共8种基本类型。

常量与类型

java中默认的整数类型是int类型
java中默认的浮点类型是double类型
过大的整数需要在数字后加“L”
3.14没有后缀，所以它是double类型
5.28D为double类型
1.26F为float类型

定义变量

定义变量的语法格式：

数据类型 变量名 = 数据值；
int a = 100;

练习代码

public class Variable {
	public static void main(String[] args) {
		int a = 10;
		double b = 3.14;
		char c = 'z';
		String s = "i love java";
		a = 20;
		System.out.println(a);
	}
}

变量定义后可以不赋值，使用时再赋值。不赋值不能使用。
变量有自己的作用范围，在一个大括号内
变量不允许重复定义

public static void main(String[] args) {
int x;
x = 20; //为x赋值20
System.out.println(x);//读取x变量中的值，再打印
}

数据类型转换

范围小的数据类型值（如byte），可以直接转换为范围大的数据类型值（如int）
范围大的数据类型值（如int），不可以直接转换为范围小的数据类型值（如byte）
各种数据类型按照数据范围从小到大依次列出：

byte -> short -> int -> long -> float -> double

自动转换

表示范围小的数据类型转换成范围大的数据类型，这种方式称为自动类型转换
范围大的数据类型 变量 = 范围小的数据类型值；
其中布尔类型，不参与类型转换

public class LearnCode {
    public static void main(String[] args){
        double a = 1000;//出现类型自动转换，int自动转换成double
        int i = 100;
        double a2 = i;
        System.out.println(i);
        System.out.println(a);
        System.out.println(a2);
    }
}

强制转换

表示范围大的数据类型转换成范围小的数据类型，这种方式称为强制类型转换
强制类型转换格式：
范围小的数据类型 变量 = (范围小的数据类型) 范围大的数据类型值;

public class DataConvert1 {
    public static void main(String[] args){
        double d = 3.14;
        int i = (int)d;
        byte b = (byte)200;//损失精度，结果-56
        System.out.println(b);
        System.out.println(i);
    }
}

运算符

算术运算符

算数运算符++、- -的使用

赋值运算符

比较运算符

逻辑运算符

当使用短路与或者短路或时，只要能判断出结果则后边的部分就不再判断。

短路与&&:参与运算的两边数据，有false，则运算结果为false；
短路或||:参与运算的两边数据，有true，则运算结果为true；
逻辑非! : 参与运算的数据，原先是true则变成false，原先是false则变成true。

三元运算符

(条件表达式)？表达式1：表达式2
先判断条件表达式的值，若为true，运算结果为表达式1；若为false，运算结果为表达式2。

运算符优先级

引用数据类型

与定义基本数据类型变量不同，引用数据类型的变量定义及赋值有一个相对固定的步骤或格式。

数据类型 变量名 = new 数据类型();

每种引用数据类型都有其功能，我们可以调用该类型实例的功能。

变量名.方法名();

Scanner类

Scanner类是引用数据类型的一种，我们可以使用该类来完成用户键盘录入，获取到录入的数据。
Scanner使用步骤：

导包：import java.util.Scanner;
创建对象实例：Scanner sc = new Scanner(System.in);

调用方法：

int  i = sc.nextInt(); //用来接收控制台录入的数字 		
String s = sc.next();//用来接收控制台录入的字符串

import java.util.Scanner;
public class ScannerDemo01 {
	public static void main(String[] args) {
		//创建Scanner引用类型的变量
		Scanner sc = new Scanner(System.in);
		//获取数字
		System.out.println("请输入一个数字");
		int n = sc.nextInt();
		System.out.println("n的值为" + n);
		//获取字符串
		System.out.println("请输入一个字符串");
		String str = sc.next();
		System.out.println("str的值为" + str);
	}
}

随机数类Random

用来产生随机数的类Random，它也属于引用数据类型
public int nextInt(int maxValue) 产生[0,maxValue)范围的随机整数，包含0，不包含maxValue；
public double nextDouble() 产生[0,1)范围的随机小数，包含0.0，不包含1.0。

import java.util.Random;

public class RandomDemo {
	public static void main(String[] args) {
		// 创建Random类的实例
		Random r = new Random(); 
		// 得到0-100范围内的随机整数，将产生的随机整数赋值给i变量
		int i = r.nextInt(100); 
		//得到0.0-1.0范围内的随机小数，将产生的随机小数赋值给d变量
		double d = r.nextDouble(); 
		System.out.println(i); 
		System.out.println(d); 
	}
}

流程控制语句

选择结构if—else

if…else语句是指如果满足某种条件，就进行某种处理，否则就进行另一种处理。

if (判断条件){
执行语句1
……
}else{
执行语句2
……
}

public class IfDemo02 {
	public static void main(String[] args) {
		int num = 19;
		if (num % 2 == 0) {
			// 判断条件成立，num被2整除
			System.out.println("num是一个偶数");
		} else {
			System.out.println("num是一个奇数");
		}
	}
}

循环语句while

while循环语句和选择结构if语句有些相似，都是根据条件判断来决定是否执行大括号内的执行语句。区别在于，while语句会反复地进行条件判断，只要条件成立，{}内的执行语句就会执行，直到条件不成立，while循环结束。while循环语句的语法结构如下：

while(循环条件){
执行语句
………
}

在上面的语法结构中，{}中的执行语句被称作循环体，循环体是否执行取决于循环条件。当循环条件为true时，循环体就会执行。循环体执行完毕时会继续判断循环条件，如条件仍为true则会继续执行，直到循环条件为false时，整个循环过程才会结束。

public class WhileDemo {
	public static void main(String[] args) {
		int x = 1; // 定义变量x，初始值为1
		while (x <= 4) { // 循环条件
			System.out.println("x = " + x); // 条件成立，打印x的值
			x++; // x进行自增
		}
	}
}

循环语句for

循环语句do…while

switch循环

数组

数组是指一组数据的集合，数组中的每个数据被称作元素。在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。

数据类型[] 数组名 = new 数据类型[元素个数或数组长度];

JVM的内存划分

JVM在堆内存，开空间，存储数组容器

int[] arr = new int[3];
System.out.println(arr);
直接打印，输出的是数组在内存中的首地址

arr引用类型，保存的数据，实质是内存中的地址。

数组的内存图

数组的定义

数据类型[] 数组名 = new 数据类型[元素个数或数组长度];
类型[] 数组名 = new 类型[]{元素，元素，……};
类型[] 数组名 = {元素，元素，元素，……};

1	public class ArrayDemo03 {
 2		public static void main(String[] args) {
 3			int[] arr = { 1, 2, 3, 4 }; // 静态初始化
 4			// 下面的代码是依次访问数组中的元素
 5			System.out.println("arr[0] = " + arr[0]);
 6			System.out.println("arr[1] = " + arr[1]);
 7			System.out.println("arr[2] = " + arr[2]);
 8			System.out.println("arr[3] = " + arr[3]);
 9		}
 10	}

上述代码中采用静态初始化的方式为数组每个元素赋予初值，分别是1、2、3、4。需要注意的是，第3行代码千万不可写成int[] arr = new int[4]{1,2,3,4};，这样写编译器会报错。原因在于编译器会认为数组限定的元素个数[4]与实际存储的元素{1,2,3,4}个数有可能不一致，存在一定的安全隐患。

遍历数组

public class ArrayDemo04 {
	public static void main(String[] args) {
		int[] arr = { 1, 2, 3, 4, 5 }; // 定义数组
		// 使用for循环遍历数组的元素
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]); // 通过索引访问元素
		}
	}
}

获取数组元素最值

public class ArrayDemo05 {
	public static void main(String[] args) {
		int[] arr = { 4, 1, 6, 3, 9, 8 }; // 定义一个数组
int max = arr[0]; // 定义变量max用于记住最大数，首先假设第一个元素为最大值
		// 下面通过一个for循环遍历数组中的元素
		for (int x = 1; x < arr.length; x++) {
			if (arr[x] > max) { // 比较 arr[x]的值是否大于max
				max = arr[x]; // 条件成立，将arr[x]的值赋给max
			}
		}
		System.out.println("max=" + max); // 打印最大值
	}
}

二维数组

格式1：

数据类型[][] 数组名 = new 数据类型[m][n];

m: 代表二维数组中一维数组的个数
n: 代表每个一维数组中元素的个数
格式2：

数据类型[][] 数组名 = new 数据类型[m][];

m: 代表二维数组中一维数组的个数

每一个一维数组通过赋值来确定数组长度
格式3：

数据类型[][] 数组名 = {{元素值1，元素值2,…},{元素值1，元素值2,…},…};

数组常见异常

NullPointerException: 空指针异常
在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常，接下来通过一个案例来演示这种异常

1	public class ArrayDemo07 {
 2		public static void main(String[] args) {
 3			int[] arr = new int[3]; // 定义一个长度为3的数组
 4			arr[0] = 5; // 为数组的第一个元素赋值
 5			System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
 6			arr = null; // 将变量arr置为null
 7			System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
 8		}
 9	}

ArrayIndexOutOfBoundsException: 数组越界异常

ASCII码

• 数字0-9对应ASCII编码十进制为48-57
• 字母a-z对应ASCII编码十进制为97-122
• 字母A-Z对应ASCII编码十进制为65-90

ASCII编码表
英文全称
American Standard Code for Information Interchange，美国标准信息交换代码
ASCII编码表由来
计算机中，所有的数据在存储和运算时都要使用二进制数表示
a、b、c、d这样的52个字母（包括大写）、以及0、1等数字还有一些常用的符号, 在计算机中存储时也要使用二进制数来表示
具体用哪些二进制数字表示哪个符号，当然每个人都可以约定自己的一套（这就叫编码）
大家如果要想互相通信而不造成混乱，那么大家就必须使用相同的编码规则，于是美国有关的标准化组织就出台了ASCII编码，统一规定了上述常用符号用哪些二进制数来表示。

Char类型的存储

• char类型的存储
• char: 占两个字节,是无符号数据,取值范围0-65536

public class ASCIIDemo {
    public static void main(String[] args){
        char c = 'a';
        int i = c+1;
        System.out.println(i);

        int j = 90;
        char h =(char)j;
        System.out.println(h);

        System.out.println((char)6);
    }
}

四、Java基础语法

方法

在Java中，声明一个方法的具体语法格式如下：

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．){
执行语句 ………
return 返回值;
}

修饰符：方法的修饰符比较多，有对访问权限进行限定的，有静态修饰符static，还有最终修饰符final等
返回值类型：用于限定方法返回值的数据类型
参数类型：用于限定调用方法时传入参数的数据类型
参数名：是一个变量，用于接收调用方法时传入的数据
return关键字：用于结束方法以及返回方法指定类型的值
返回值：被return语句返回的值，该值会返回给调用者
需要特别注意的是，方法中的“参数类型 参数名1，参数类型 参数名2”被称作参数列表，它用于描述方法在被调用时需要接收的参数，如果方法不需要接收任何参数，则参数列表为空，即()内不写任何内容。方法的返回值必须为方法声明的返回值类型，如果方法中没有返回值，返回值类型要声明为void，此时，方法中return语句可以省略。

public class MethodDemo01 {
	public static void main(String[] args) {
		int area = getArea(3, 5); // 调用 getArea方法
		System.out.println(" The area is " + area);
	}

	// 下面定义了一个求矩形面积的方法，接收两个参数，其中x为高，y为宽
	public static int getArea(int x, int y) {
		int temp = x * y; // 使用变量temp记住运算结果
		return temp; // 将变量temp的值返回
	}
	public static void printRect2(int m,int n){
        //指定打印m行
        for(int i=1;i<=m;i++){
            //打印n个*
            for(int j=1;j<=n;j++){
                System.out.print("*");
            }
            System.out.println();//打印完一行，换行
        }
    }
}

在程序运行期间，参数x和y相当于在内存中定义的两个变量。当调用getArea()方法时，传入的参数3和5分别赋值给变量x和y，并将x*y的结果通过return语句返回，整个方法的调用过程结束，变量x和y被释放。

方法的重载

Java允许在一个类中定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载。

我们假设要在程序中实现一个对数字求和的方法，由于参与求和数字的个数和类型都不确定，因此要针对不同的情况去设计不同的方法。接下来通过一个案例来实现对两个整数相加、对三个整数相加以及对两个小数相加的功能，具体实现如下所示

public class MethodDemo02 {
	public static void main(String[] args) {
		// 下面是针对求和方法的调用
		int sum1 = add01(1, 2);
		int sum2 = add02(1, 2, 3);
		double sum3 = add03(1.2, 2.3);
		// 下面的代码是打印求和的结果
		System.out.println("sum1=" + sum1);
		System.out.println("sum2=" + sum2);
		System.out.println("sum3=" + sum3);
	}

	// 下面的方法实现了两个整数相加
	public static int add01(int x, int y) {
		return x + y;
	}
	// 下面的方法实现了三个整数相加
	public static int add02(int x, int y, int z) {
		return x + y + z;
	}
	// 下面的方法实现了两个小数相加
	public static double add03(double x, double y) {
		return x + y;
	}
}

从上述代码不难看出，程序需要针对每一种求和的情况都定义一个方法，如果每个方法的名称都不相同，在调用时就很难分清哪种情况该调用哪个方法。
接下来通过方法重载的方式进行修改，如下所示。

public class MethodDemo03 {
	public static void main(String[] args) {
		// 下面是针对求和方法的调用
		int sum1 = add(1, 2);
		int sum2 = add(1, 2, 3);
		double sum3 = add(1.2, 2.3);
		// 下面的代码是打印求和的结果
		System.out.println("sum1=" + sum1);
		System.out.println("sum2=" + sum2);
		System.out.println("sum3=" + sum3);
	}

	// 下面的方法实现了两个整数相加
	public static int add(int x, int y) {
		return x + y;
	}
	// 下面的方法实现了三个整数相加
	public static int add(int x, int y, int z) {
		return x + y + z;
	}
	// 下面的方法实现了两个小数相加
	public static double add(double x, double y) {
		return x + y;
	}
}

上述代码中定义了三个同名的add()方法，它们的参数个数或类型不同，从而形成了方法的重载。
在main()方法中调用add()方法时，通过传入不同的参数便可以确定调用哪个重载的方法，如add(1,2)调用的是两个整数求和的方法。

重载的注意事项

值得注意的是，方法的重载与返回值类型无关，它只有两个条件，一是方法名相同，二是参数个数或参数类型不相同。

重载方法参数必须不同：
参数个数不同，如method(int x)与method(int x,int y)不同
参数类型不同，如method(int x)与method(double x)不同g
参数顺序不同，如method(int x,double y)与method(double x,int y)不同

重载只与方法名与参数类型相关与返回值无关
如void method(int x)与int method(int y)不是方法重载，不能同时存在

重载与具体的变量标识符无关
如method(int x)与method(int y)不是方法重载，不能同时存在

参数传递

定义方法时，参数列表中的变量，我们称为形式参数
调用方法时，传入给方法的数值，我们称为实际参数

基本数据类型传参

方法参数是基本类型时，传递的是值。
当调用方法时，如果传入的数值为基本数据类型（包含String类型），形式参数的改变对实际参数不影响

public class ArgumentsDemo01 {
	public static void main(String[] args) {
		int a=5;
		int b=10;
		change(a, b);//调用方法时，传入的数值称为实际参数
		System.out.println("a=" + a);
		System.out.println("b=" + b);
	}

	public static void change(int a, int b){//方法中指定的多个参数称为形式参数
		a=200;
		b=500;
	}
}

引用数据类型传参

方法参数是引用类型时，传递的是内存地址值
当调用方法时，如果传入的数值为引用数据类型（String类型除外），形式参数的改变对实际参数有影响

public class ArgumentsDemo02 {
	public static void main(String[] args) {
		int[] arr = { 1, 2, 3 };
		change(arr);// 调用方法时，传入的数值称为实际参数
		
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}

	public static void change(int[] arr) {// 方法中指定的多个参数称为形式参数
		for (int i = 0; i < arr.length; i++) {
			arr[i] *= 2;
		}
	}
}

总结：

在传递基本数据类型参数时，main方法压栈执行，定义a,b变量，然后调用change方法，此时change方法压栈执行，此时将a,b变量的值传入change方法中，但是对a,b变量并未做任何改变，因此，输出a,b值不变。

在传递引用数据类型参数时，main方法压栈执行，在堆内存中开空间，存储arr数据，此时arr引用对内部才能中的地址，然后调用change方法，此时change方法压栈执行，此时将arr数组地址传入change方法中，因为会影响实际参数的值。

引用数据类型（类）

• 数据类型
  java中的数据类型分为：基本类型和引用类型

• 引用类型的分类

• Java为我们提供好的类，比如说：Scanner,Random等。
• 我们自己创建的类，按照类的定义标准，可以在类中包含多个方法与属性，来供我们使用。

类的定义与使用

• 自定义类的格式
  * 使用类的形式,对现实中的事物进行描述。
  * 事物由方法和属性两部分组成。
  * 方法: 这个事物具备的功能。
  * 属性: 这个事物具备的特征。
  * 格式

public class 类名{
属性定义
修饰符 数据类型 变量名 = 值
方法定义
修饰符 返回值类型 方法名(参数列表){
} }

public class Phone {
	/*
	 * 属性
	 */
	String brand;// 品牌型号
	String color;// 颜色
	double size; // 尺寸大小
}

Phone类定义好后，我们就可以使用这个类了，使用方式和使用引用数据类型Scanner类相似。格式如下：
导包：我们将所有的类放到同一个文件夹下，可以避免导包。
创建对象：数据类型 变量名 = new 数据类型();
调用方法：目前我们定义的自定义类不涉及方法，只是属性（自定义类中的方法部分在面向对象部分讲解）
访问属性：变量名.属性 (这是当前的方式，后期会采取调用方法的方式替代掉直接访问的方式来完成对属性的访问。)

当有了Phone数据类型的变量后，我们就可以使用Phone类中的属性了。对属性的访问我们来演示一下

public class Test {
	public static void main(String[] args) {
		//定义了一个Phone类型的变量p
		Phone p = new Phone();
		/*
		 * 通过p,使用Phone中的属性
		 */
		//访问p中的brand品牌属性
        p.brand = "苹果6s";
//访问p中的color颜色属性
		p.color = "白色";
//访问p中的size尺寸大小属性
        p.size = 5.5;
System.out.println("手机品牌为" + p.brand);
System.out.println("手机颜色为" + p.color);
System.out.println("手机尺寸大小为" + p.size);
	}
}

通过 p.属性名 就可以对属性进行操作

与引用类型数组类似，引用类型的自定义类型的变量，直接变量时，结果为对象地址值，这里可以通过内存图简单解释。

ArrayList集合

ArrayList集合是程序中最常见的一种集合，它属于引用数据类型（类）。在ArrayList内部封装了一个长度可变的数组，当存入的元素超过数组长度时，ArrayList会在内存中分配一个更大的数组来存储这些元素，因此可以将ArrayList集合看作一个长度可变的数组。

集合的创建

• 引用数据类型 步骤 导包：import java.util.ArrayList;
• 创建对象：与其他普通的引用数据类型创建方式完全相同，但是要指定容器中存储的数据类型：
• ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();
• 集合中存储的元素，只能为<>括号中指定的数据类型元素；
• “<要存储元素的数据类型>”中的数据类型必须是引用数据类型，不能是基本数据类型；

ArrayList集合提供的一些常用方法，如下表：

import java.util.ArrayList;
public class ArrayListDemo {
    public static void main(String[] args){
        ArrayList<String> array1 = new ArrayList<String>();

        ArrayList<Integer> array2 = new ArrayList<Integer>();

        ArrayList<Phone> array3 = new ArrayList<Phone>();

        array1.add("小明");
        array1.add("小红");
        array1.add("小军");
        //遍历集合
        for (int i=0;i<array1.size();i++){
            String name = array1.get(i);
            System.out.println(name);
        }
    }
}

ArraayList方法补充

import java.util.ArrayList;

public class ArrayListDemo1 {

    public static void main(String[] args){
        ArrayList<Integer> array = new ArrayList<Integer>();
        array.add(1);
        array.add(2);
        array.add(3);
        array.add(4);
        //在索引2上，添加元素7
        array.add(2,7);
        //把索引0上的元素，修改为10
        array.set(0,10);
        //删除3索引上的元素
        array.remove(3);
        for (int i=0;i<array.size();i++){
            System.out.println(array.get(i));
        }
        //清空元素
        array.clear();
        System.out.println(array);
    }


}