1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 整型
byte        1字节     -128~127
short       2字节     
int(默认)    4字节     21亿
long        8字节     19位数     long lg = 2343453234232L;// long类型的数据必须在后面加上L/l

// 浮点型
float           4
double(默认)     8            float ft = 3.14F; // float类型需要以f/F结尾

// 字符型
char         2

// 布尔型
boolean      1

1
2
3
4
5
6

// 类型范围小的变量，可以直接赋值给类型范围大的变量
byte a = 12;
int b = a;

char ch = 'b';
int it = ch;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

byte a = 10;
int b = 20;
long c = 30;
// 小范围类型的变量，会自动转换成表达式中较大范围的类型，再参与运算
// 表达式的最终结果类型由表达式中的 最高类型决定
long result = a + b + c;


// 在表达式中，byte、short、char是`直接转换成int`类型参与运算的
byte a1 = 10;
byte a2 = 20;
// byte a3 = a1 + a2; // 报错，因为，在表达式中，byte、short、char是`直接转换成int`类型参与运算的
int a3 = a1 + a2;

1
2
3
4
5
6

// 大范围类型的变量 => 小范围类型的变量
int a = 20;
byte b = (byte)a;

int i = 1500;
byte j = (byte)i; // Alt+enter, 强制类型转换可能出现数据溢出(失真)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 数据类型  变量名称  =  数据;
int age = 18;

// 变量定义的时候可以不赋初始值，但在使用时，变量里必须有值
double price;
price = 15.4;

// 二进制，以`0B`或`0b`开头

// 八进制，以`0`开头

// 十六进制，以`0X`或`0x`开头

// 关键ASCII值
a   =>  97
A   =>  65
0   =>  48

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// `+`符号与字符串运算的时候是用作`连接符`使用的，原则：`能算则算，不能算则连接在一起`
int a = 5;
System.out.println("abc"+a); // abc5
System.out.println(a+5); // 10
System.out.println("abc"+a+'a'); // abc5a
System.out.println('a'+a+"abc"); // 102abc


// 自增自减
int i = 10;
int rs = ++i; // ++/--在前，先自加后赋值
System.out.println(i); // 11
System.out.println(rs); // 11

int j = 10;
int rs2 = j++; // ++/--在后，先赋值后自加/自减
System.out.println(j); // 11
System.out.println(rs2); // 10


// 逻辑与   &    全为true，结果才为true

// 逻辑或   |    有一个为true，结果就为true

// 逻辑非   !

// 逻辑异或  ^    前后结果一致，返回false，前后结果不同，返回true

// 短路与   &&    左边只要出现false，右边就不执行

// 短路或   ||    左边只要出现true，右边就不执行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// if
if() {
  
} else if() {
  
} else{
  
}

// switch
switch(表达式){
  case 值1:
  case 值2: // 穿透现象
    执行代码1;
    break;
   ...
   case 值n-1:
    执行代码n-1;
    break;  
  default:
    执行代码n;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// for循环
for(int i = 0;i<3;i++){
	System.out.println("hello world");
}

// while循环
while(循环条件){
  循环体语句(被重复执行的代码);
  迭代语句;
}

// do while循环
do{
  循环体语句;
  迭代语句;
} while (循环条件);


// 死循环
// for死循环
for(;;){
  System.out.println("hello world");
}
// while死循环
while(true){
  System.out.println("hello world");
}
// do-while死循环
do{
  System.out.println("hello world");
} while(true);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 静态数组
// 完整格式
int[] ages = new int[]{12,16,18};

// 简化格式
int[] ages = {12,16,18};
// 以上代码也可以这样写
int ages[] = {12,16,18};

// 动态数组：数组定义时先不存入具体的元素值，`只确定数组存储的数据类型和数组的长度`
int[] arr = new int[3];
// 动态数组默认值
byte，short，char，int，long      默认值0
float，double                    默认值0.0
boolean                         默认值false
引用类型（数组等）                 默认值null

1
2
3
4

修饰符 返回值类型 方法名(形参列表) {
  方法体代码(需要执行的功能代码)
    return 返回值;
}

1
2
3

public static void sum(int...nums){
  // 可变参数在方法内部本质就是一个数组
}

1
2

// 用在方法中，代表当前对象
// 在类方法中，访问类属性（用来解决对象的成员变量与方法内部变量的名称一样时，导致访问冲突问题）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Student{
  // 无参构造器
  public Student() {}
  // 有参构造器
  public Student(String name) {}
}

Student s = new Student();// 这句代码执行了2步操作：
// 1、new Student创建对象
// 2、()匹配调用无参构造器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class Animal{
    public Animal(){
        System.out.println("父类Animal的无参构造器执行了");
    }
    public Animal(String name){
        System.out.println("父类Animal的有参构造器执行了");
    }
}

public class Wolf extends Animal {
    public Wolf() {
//        super(); // 写不写都不影响，默认都会调用父类的无参构造器，如果父类没有无参构造器就会报错
    }
   public Wolf(String n){
        // super(); // 写不写都不影响，默认都会先调用父类的无参构造器，如果父类没有无参构造器就会报错
         super(n); // 我们可以手动去调用父类的有参构造器，这样即使没有无参构造器，也不会报错了
        System.out.println("子类Wolf的有参构造器执行了"); // 父类Animal的无参构造器执行了    子类Wolf的有参构造器执行了
    }
}


public static void main(String[] args){
  Wolf w1 = new Wolf();
  Wolf w2 = new Wolf("七匹狼");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Student {
  public Student() {}
  public Student(String name,int age){
      // this调用兄弟构造器
      this(name,age,"默认学校");
  }
  public Student(String name, int age, String school) {
    ...
  }
}

1

public class B extends A{}

1
2
3

public class M{}
public class N extends M{}
public class P extends N{}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class Fu{
  String name = "父类名称";
}
public class Zi extends Fu{
  String name = "子类名称";
  
  public void showName(){
    String name = "局部名称";
    System.out.println(name); // 局部名称
    System.out.println(this.name); // 子类名称
    System.out.println(super.name); // 父类名称
  }
}

1
2
3

People p1 = new Student(); // 父类（People）引用子类对象（new Student()）
Perple p2 = new Teacher(); // 父类（People）引用子类对象（new Teacher()）
Student p3 = new Student(); // 不是多态，不是：父类引用子类对象

1
2
3
4
5
6
7

People p1 = new Student();
// 成员方法：编译看左（People中是否有run方法），运行看右（运行Student中的run方法）
p1.run();//行为多态  
// 成员属性：编译看左，运行看左
System.out.println(p1.name);
Perple p2 = new Teacher();
p2.run();//行为多态

1
2
3
4

// 自动类型转换
People p = new Teacher();
// 强制类型转换(People必须与Teacher有继承关系)
Teacher t = (Teacher)p;

1
2
3
4

// 为了避免类型转换异常(ClassCastException)出现
if(a instanceof Cat){
  Cat c1 = (Cat)a;
}

1
2
3
4
5
6

# 静态变量
类名.变量名(推荐)
对象名.变量名(不推荐)
  
# 实例变量
对象.变量名

1
2
3
4
5
6

# 静态方法
类名.类方法(推荐)
对象名.类方法(不推荐)
  
# 实例变量
对象.类方法

1
2
3

static{
  // 初始化数据
}

1
2
3

{
  // 初始化赋值
}

1
2
3

public static void buy(final double z){ // 使用final保证该参数无法被修改
  
}

1

public static final String CIRCLE_PAI = "3.14";

1
2
3

public abstract class A{
  public abstract void go();
}

1
2
3
4
5

// 实现类实现多个接口，必须重写全部接口的全部抽象方法，否则这个类必须是抽象类
// 实现类名以`Impl`结束
修饰符 class 实现类 implement 接口1,接口2,接口3,...{
  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

interface A{
  void a();
}
interface B{
  void b();
}
interface C{
  void c();
}

// 实例类D
class D implements A,B,C{
	// 实现A，B，C中所有方法
}


// 多继承写法
interface A extends B,C{
  void a();
}
class D implements A{
	// 实现A，B，C中所有方法
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// jdk1.8之前，接口内只能定义`常量`和`抽象方法`
public interface A{
  // 常量：接口中定义常量可以省略public static final不写，默认会加上
  String ERROR_CODE = "10000";
  
  // 抽象方法：接口中定义抽象方法可以省略 public abstract不写，默认会加上
  void run();
}


// jdk8开始，接口新增了三种形式的方法
public interface A{
  // 1、默认方法（普通方法、实例方法），必须用default修饰
  // 默认会用public修饰
  // 必须用接口的实现类的对象来调用
  default void run(){
    go();
    System.out.println("run方法在执行");
  }
  
  // 2、私有方法（私有的实例方法）（JDK9开始才有的）
  // 只有当前接口内部的默认方法或私有方法来调用
  private void go(){
    System.out.println("go方法在执行");
  }
  
  // 3、静态方法
  // 默认会用public修饰
  // 接口的静态方法必须用接口名本身调用 A.inAddr();
 	static void inAddr(){
    System.out.println("inAddr方法在执行");
  }
}

// 新增3种方法目的：增强了接口的能力，更便于项目的扩展和维护
//（假设我们设计的接口A，已经设计好了抽象方法，有1000个类实现了接口A。这时我们的项目新增了一个功能，我们需要在接口A中新增一个抽象方法（jdk8之前），那我们需要修改这1000个实现类，这时候代码维护性就很差了。

// 而新增的3种方法后，我们可以将这个新增方法，使用这3种方法写到接口A中，直接调用就可以了，不用对1000个实现类进行修改了）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 1、使用Override注解，好处：
// 1.安全：java编译器会检查我们方法 重写的格式是否正确
// 2.代码的可读性更好（看到Override就会直到这是重写方法）
public class Tigger extends Animal{
  @Override
  public void run(){}
}

// 2、子类重写父类方法时，访问权限必须大于或等于父类该方法的权限

// 3、重写的方法返回值类型，必须与被重写方法的返回值类型一致，或则范围更小

// 4、私有方法、静态方法不能被重写，如果重写会报错的
// 1.私有的方法无法被继承，既然没有继承就没有重写之说了。
// 2.静态方法时属于父类的
// 3.当我们去掉`Override`后，方法是覆盖而不是重写

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

public class Outer{
  public class Inner{
    
  }
}
// 1、使用内部类,Inner内部类是外部类的对象持有的
Outer.Inner in = new Outer().new Inner();

// 2、成员内部类的实例方法中，可以直接访问外部类的实例成员、静态成员（因为是先有了外部实例，再有内部实例，因此可以调用外部类的实例成员）
public class Outer{
  public static String schoolName = "学校";
  public static void inAddr(){
    System.out.println("我们在济南");
  }
  private String hobby;
  private void run(){
    System.out.println("run");
  }
  public class Inner{
   public void show(){
     // 成员内部类中，可以直接访问外部类的静态成员
     System.out.println(schoolName);
     // 成员内部类中，可以直接访问外部类的静态方法
     inAddr();
     // 成员内部类中，可以直接访问外部类的实例成员
     System.out.println(hobby);
     // 成员内部类中，可以直接访问外部类的实例方法
     run();
   } 
  }
}


// 3、获取当前外部类对象，格式：外部类名.this
public class People{
  private int heartBeat = 110;
  public class Heart{
    private int heartBeat = 95;
    public void show(){
      int heartBeat = 80;
      System.out.println(heartBeat); // 80
      System.out.println(this.heartBeat); // 95
      System.out.println(People.this.heartBeat); // 110 注意这里写法 
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Outer{
  // 静态内部类
  public static class Inner{}
}

// 1、直接使用静态内部类
Outer.Inner in = new Outer.Inner();
// 2、注意
// 2.1 静态成员内部类中，可以直接访问外部类的静态成员、静态方法
// 2.2 静态成员内部类中，不可以直接访问外部类的实例成员、实例方法

1
2
3
4

public static void main(String[] args){
  // 局部内部类（鸡肋语法，没有什么用）
  class A{}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 匿名类作为一个参数传递
interface Swimming{
 	void swim();
}
public class Trial{
  public static void main(String[] args){
    // Trail类中的匿名类在编译后形成的文件名是：Trial$1.class（当前类名+$+编号）
    Swimming s1 = new Swimming(){
      @Override
      public void swim(){
        System.out.print("学生在有用");
      }
    };
    go(s1);
  }
 
  public static void go(Swimming s){
    System.out.println("开始....");
    s.swim();
     System.out.println("结束....");
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// 使用`@FunctionalInterface`注解的接口必定是函数式接口
@FunctionalInterface
interface Swimming{
  void swim();
}
Swimming s1 = new Swimming(){
  @override
  public void swim(){
    System.out.println("yyyy");
  }
}
// 使用Lambda表达式简化
Swimming s1 = () -> {
  System.out.println("yyyy");
}

// Lambda省略规则
// 1、参数类型可以省略不写
Arrays.setAll(scores,(int index) -> {
  return scores[index]+10;
});
Arrays.setAll(scores,(index) -> {
  return scores[index]+10;
});
// 2、如果只有一个参数，参数类型可以省略，同时()也可以省略
Arrays.setAll(scores,index -> {
  return scores[index]+10;
});
// 3、如果Lambda表达式中的 方法体代码只有一行代码， 可以省略大括号不写，同时要省略分号！此时，如果这行代码是return语句，也必须去掉return不写
Arrays.setAll(scores,index -> scores[index]+10);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

// 1、静态方法引用：类名::静态方法
// lambda表达式中只是调用一个静态方法，并且前后参数形式一致，可以使用
// Comparable必须是函数式接口
public class Student implements Comparable<Student>{
  public static int compareByHeight(Student s1,Student s2){
    return Double.compare(a1.getHeight(),a2.getHeight());
  }
}
Student[] students = new Student[4];
// Lambda写法
Arrays.sort(student,(a1,a2)->Double.compare(a1.getHeight(),a2.getHeight()));
// 静态方法引用写法
Arrays.sort(students,Student::compareByHeight);


// 2、实例方法引用：实例名::实例方法
// Lambda表达式里只是调用一个实例方法，并且前后参数的形式一致，就可以使用
// Test类中的compare方法
public int compare(Student s1,Student s2){
  retrun Double.compare(s1.getHeight(),s2.getHeight());
}
Test t = new Test();
// Lambda写法
Arrays.sort(students,(a1,a2)->t.compare(a1,a2));
// 实例方法引用写法
Arrays.sort(students,t::compare);


// 3、特定类型的方法引用：类型::方法
// Lambda表达式里只是调用一个实例方法，并且前面参数列表中的第一个参数是作为方法的主调，后面的所有参数都是作为该实例方法的入参的，则此时就可以使用特定类型的方法引用
// 原始写法
Arrays.sort(names,new Comparator<String>(){
  @Override
  public int compare(String s1,String s2){
    return s1.compareToIgnoreCase(s2);
  }
});
// Lambda写法
Arrays.sort(names,(s1,s2) -> s1.compareToIgnoreCase(s2));
// 特定类型的方法引用
Arrays.sort(names, String::compareToIgnoreCase);


// 4、构造器引用：类型::new
// Lambda表达式里只是在创建对象，并且前后参数情况一致，就可以使用构造器引用
@FunctionalInterface
interface Create{
  Car createCar(String name);
}

class Car{
  private String name;
}
// 原始写法
Create c1 = new Create(){
  @Override
  public Car createCar(String name){
    return new Car(name);
  }
};
// 原始写法简化
Create c1 = (String name) -> {
  return new Car(name);
};
// Lambda写法
Create c1 = name -> new Car(name);
// 如果某个Lambda表达式里只是在创建对象，并且前后参数情况一致，就可以使用构造器引用
Create c1 = Car::new;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 枚举类的第一行必须罗列的是枚举对象的名称
public enum A{
  X,Y,Z;// 这些名称，本质是常量，每个常量都会记住枚举类的一个对象，可以通过查看反编译后的代码：public static final A X = new A();
  private String name;
}
// 使用枚举
A a1 = A.X; // 等同于 A.valueOf("X");
// 获取对应的枚举的索引
a1.ordinal();
// 获取枚举类的全部对象，返回结果为数组
A[] a = A.values();

1
2
3
4

// 枚举写的单例
public Enum B{
  X;
}

1

ArrayList<String> list = new ArrayList<String>();// jdk1.7之后后面的ArrayList<String>中的String可以不写

1
2
3

public class ArrayList<E>{
  
}

1
2
3

public interface A<E,T>{
  ....
}

1
2
3
4
5
6

修饰符 <类型变量,类型变量，...> 返回值类型 方法名(形参列表){
  
}
public static <T> T printArray(T[] arr){
  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class Car{}
class TSL extends Car{}
class LX extends Car{}

// 通配符： ?
public static void go(ArrayList<?> tsls){} // 可以传递任意类型
// 泛型上限：能接收的必须是Car或者其子类
public static void go(ArrayList<? extends Car> tsls){}
// 泛型下限：能接收的必须是Car或者其父类
public static void go(ArrayList<? super Car> tsls){}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

int a = 12;
// 1、手动包装：int成对象
Integer it1 = new Integer(a); // 过时了，jdk9就淘汰了
Integer it2 = Integer.valueOf(a); // 推荐，缓存了-128到127之间的数据成为一个个对象（不会每次都new），如果不在这个范围，就重新new一个返回

// 2、自动装箱机制：基本类型的数据可以直接变成对象赋值给包装类
Integer it3 = 12; // 等同于上面的手动包装

// 3、自动拆箱机制:包装类的对象可以直接赋值给基本数据类型
int it8 = it7;
System.out.println(it8); // 128

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// 把基本数据类型转换成字符串
// 1、方式1
int a1 = 32;
String rs = Integer.toString(a1);

// 2、方式2
Integer i = 23;
String rs2 = i.toString();

// 3、方式3
int a2 = 23;
String rs3 = a2 + "";

// 把字符串数值转换成对应的基本数据类型
String ageStr = "23";
int age = Integer.parseInt(ageStr); // 等同于Integer.valueOf(ageStr);


String scoreStr = "99.5";
int score = Double.parseDouble(scoreStr);// 等同于Integer.valueOf(scoreStr);

1

package com.snailsir.javabean;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

qq.matches("[1-9]\\d{5,}"); // 是否能匹配正则表达式

// Pattern根据正则获取内容
// 1、获取Pattern对象
Pattern pattern = Pattern.compile("正则规则");
// 2、获取匹配器对象
Matcher matcher = pattern.matcher(data);
// 3、获取匹配对象
while(matcher.find()){
  // 获取正则匹配的内容
  String info = matcher.group();
  // 获取分组匹配的内容，使用()包起来的正则表达式
  String info = matcher.group(1);// 我们这时候就可以获取()匹配的内容
}

// 贪婪匹配
String regex1 = "欢迎(.+)光临"; // 贪婪匹配，最大范围匹配，只会匹配出一个
String regex2 = "欢迎(.+?)光临"; // 非贪婪匹配，会匹配出多个

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

String name = null;
System.out.println(name.length()); // NullPointerException 空指针异常

System.out.println(10/0);// ArithmeticException 数学操作异常

Object o = "snailsir";
Integer i = (Integer)o; // ClassCastException 类型转换异常

String s = "23a";
int it = Integer.valueOf(s); // NumberFormatException 数字转换异常

1
2
3
4
5
6
7
8

//1、继承RuntimeExcepition
public class AgeIllegalRuntimeException extends RuntimeException{
  // 2、重写构造器
  public AgeIllegalRuntimeException(){}
  publci AgeIllegalRuntimeException(String message){
    super(message);
  }
}

1
2
3
4
5
6
7
8

//1、继承Excepition
public class AgeIllegalRuntimeException extends Excepition{
  // 2、重写构造器
  public AgeIllegalRuntimeException(){}
  publci AgeIllegalRuntimeException(String message){
    super(message);
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// 创建String对象
String name = "snailsir";

String s1 = new String(); // 等同于 s1 = "";

char[] chars = {'a','b','c','中','国'};
String s3 = new String(chars);

byte[] bytes = {97,98,99,65,66,67};
String s4 = new String(bytes);

// 常用方法
String str = "snail蜗牛sir";
str.length(); // 获取字符串长度:10
str.charAt(2); // 获取指定索引对应的字符，索引从0开始
char[] chars = str.toCharArray(); // 把字符串转换成数组
//判断字符串内容是否相同
String str1 = "abc";
String str2 = new String("abc");
System.out.println(str1 == str2); // false 比较str1与str2对应的内存地址是否相同
System.out.println(str1.equals(str2)); // true 比较的是str1与str2的内容是否相同
t1.equalsIgnoreCase(t2); //忽略大小写进行字符串内容比较
str.substring(5, 7); // 截取字符串：蜗牛
str.substring(7); // 从索引7开始截取到末尾
str.replace("垃圾","**").replace("TM","xx"); // 字符串替换，返回替换后的字符串
str.contains("sir"); // 判断是否包含sir字符串
str.startsWith("snail"); // 判断字符串是否以snail开头
str.endsWith("snail"); // 判断字符串是否以snail结尾
String[] res = str.split("s");// 分割字符串成数组
String[] names = s1.split("\\w+");
String result s1.replaceAll("\\w+","-"); // 正则替换

1
2
3

String str1 = "abc";
String str2 = "abc";
System.out.println(str1 == str2); // true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

Collection<String> list = new ArrayList<String>();
// 1、添加数据
list.add("java");
// 2、清空集合
list.clear();
// 3、判断集合是否为空
list.isEmpty(); // true
// 4、删除集合中的某个数据：默认只能删除第一个
list.remove("java"); // true
// 5、判断集合中是否包含某个数据
list.contains("java"); // true
// 6、获取集合的大小（元素个数）
list.size(); // 3
// 7、把集合转化成数组
Object[] array = list.toArray();
// 8、合并两个集合的数据
c1.addAll(c2); //把c2集合中的数据添加到c1中去

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// 1、迭代器：遍历集合的专用方式（数组没有迭代器）
ArrayList<String> list = new ArrayList<String>(); 
// 1.1 获取集合的迭代器对象
Iterator<String> it = list.iterator(); // 迭代器游标指针处于第一个位置
it.next(); //  1.2 取数据，然后游标指针下移一位
...
it.next(); // 抛异常：NoSuchElementException

// hasNext()判断当前位置是否有元素存在
while(it.hasNext()){
  System.out.println(it.next());// 取数据，然后在将游标指针下移一位
}

// 2、增强for（既可以遍历集合也可以遍历数组），本质就是迭代器遍历集合的简化写法
// 2.1 增强for只能读取数据，不能修改数据（快捷键：list.for+回车键）
for(String s:list){
  System.out.println(s);
}

// 3、Lambda表达式
// 3.1 原始写法
list.forEach(new Consumer<String>(){
  @Override
  public void accept(String s){
    System.out.println(s);
  }
});
// 3.2 Lambda简化写法
list.forEach(s->System.out.println(s));
// 3.3 方法引用简化写法
list.forEach(System.out::println);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 1、使用迭代器处理
Iterator<String> it = list.iterator();
while(it.hasNext()) {
  String name = it.next();
  if(name.contains("枸杞")){
    // list.remove(name);// 使用集合删除数据方法，会出现异常：ConcurrentModifiactionException   源码中：modCount 与 exceptedModCount不一致，每删除一个数据，modCount就会自加
    it.remove();// 必须调用迭代器自己的删除方法，才不会出现bug
  }
}

// 2、使用增强for遍历集合并删除含有枸杞的元素，必然出错，而且无法解决
// 因为增强for的本质就是迭代器，而增强for无法拿到迭代器，因此无法解决

// 3、Lambda遍历集合并删除含有枸杞的元素，必然出错，而且无法解决

//4、如果是ArrayList带索引的集合，我们可以使用for循环删除后，再退一步（i--)，或者从后面倒着百年路并删除