javaSE复习回顾（每日回顾）

电玩女神 2023-06-13 15:24 13阅读 0赞

# 1.面向对象基础 #

## 1.1 方法 ##

#### 1.1.1 方法重载： ####

*  同一个类中，多个方法的方法名相同，参数列表不同，根据调用方法时的传参确定具体调用的哪个方法，构成方法重载。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70]

#### 1.1.2 方法重写： ####

*  在子类继承父类之后，对于父类中已有的方法（原方法不满足功能时）可以进行重写（覆盖），重写后的方法必须与父类中的方法的**方法名**、**返回值类型**、**参数类型**保持一致，只可以改变方法中的逻辑代码

--------------------

## 1.2 类和对象 ##

#### 1.2.1 面向对象和面向过程 ####

面向对象：虚拟世界模拟现实生活  
面向过程：按照顺序逐步完成

#### 1.2.2 类与对象关系：抽象与具体 ####

*  **类**: 同一类事物抽象描述
 *  **对象**：具体实例
 *  **属性/成员变量**：对象的特征
 *  **方法**：对象所做的事情  
    具有相同属性和方法的对象组合成一类。比如定义实体类的时候，set/get

1.  对象的内存分析![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70 1]  
    一次编写类、属性、方法、测试类（含有main方法的类，然后实例化一个Student类的对象。

步骤： main方法进栈，测试类StudentTest在方法区，执行new一个对象zs，这个对象存在堆中，栈中存放这个对象的地址。

1.  java内存划分![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70 2]

#### 1.2.3 成员变量和局部变量 ####

*  定义位置不同
 *  作用范围不同
 *  默认值不同（局部变量没有默认值）

#### 1.2.4 封装 ####

*  把一段处理逻辑的代码封装成一个方法，调用时只需注意输入和输出，不用管如何实现
 *  **private**加在实体类的对象属性前面，在该类外部，属性不能直接"."得到，必须使用**setter/getter**方法获取，可以在**setter**方法中写**if**判断，使其赋值合理，比如年龄不能赋值为负数

--------------------

## 1.3 继承 ##

#### 1.3.1 参数传递 ####

传递的参数为：

*  **基础数据类型**：每次获取参数都是本身的值，改变之后不会对其他方法的引用产生影响
 *  **引用数据类型**：传递的只是这个参数的地址，改变属性值之后，其他方法引用时，属性值也发生改变，会有影响

#### 1.3.2 static关键字 ####

1.  修饰成员变量：经过static修饰过的静态属性，被存在方法区中，被堆中的对象共享。

*  好处：只需要开辟一片空间

static String name;
    Student s1 = new Student();
    Student s2 = new Student();
    //s1、s2中的 name 是相同的，都是取的方法区中的
    
    
    String name;
    Student s1 = new Student();
    Student s2 = new Student();
    //s1、s2中的 name 不一定相同，取堆中相应对象中的属性值

#### 1.3.3 继承 ####

1.  子类继承父类的属性和方法，然后再写自己独有的属性和方法。
2.  减少代码的冗余性
3.  class A **extends** B
4.  子类不能继承父类的构造方法
5.  **new**一个对象时，可以使用无参构造方法，然后**setter**给属性赋值（常用）；也可以使用有参构造方法赋值（少用）

*  例子：  
    实体类：

public class Exer01 { 
    
        String name;
        int age;
    
        //无参构造
        public Exer01() { 
        }
    
        //有参构造
        public Exer01(String name, int age) { 
            this.name = name;
            this.age = age;
        }
    
        //setter/getter
        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;
        }
    
        //重写toString()方法---方便打印出对象详细内容，而不是只显示一个地址
        public String toString(){ 
            return "name:" + this.name + " age:" + this.age;
        }
    }

测试类：

public class ExerTest01 { 
    
        public static void main(String[] args) { 
            Exer01 e1 = new Exer01("xiaoming",18);	//使用有参构造方法赋值
            e1.setAge(19);
            System.out.println(e1.toString());	//name:xiaoming age:19
    
    
            Exer01 e2 = new Exer01();
            e2.setName("xiaoguang");
            e2.setAge(30);
            System.out.println(e2.toString());	//name:xiaoguang age:30
        }
    }

#### 1.3.4 this 和 super ####

*  **this**可以访问本类中的属性和方法，也可以访问其父类中的属性和方法
 *  **super**只能在子类中使用，用来访问其父类中的属性和方法

#### 1.3.5 实例化子类时，父类做了什么 ####

*  先执行父类的构造方法，再执行子类相匹配的构造方法  
    1.子类构造方法中没有指定，先执行父类无参构造方法  
    2.子类构造方法中指定了，先执行父类相应的构造方法  
    [子类、父类中构造方法的执行顺序][Link 1]

## 1.4 多态 ##

#### 1.4.1 定义 ####

Person p = new Student();

1.父类引用指向子类对象  
2. 优先调用子类重写以后的方法（子类必须重写父类方法）  
3.方法调用总是作用于运行期对象的实际类型，允许添加更多类型的子类实现功能扩展，却不需要修改基于父类的代码。

#### 1.4.2 好处 ####

减少代码冗余性

#### 1.4.3 条件 ####

1.  子类继承父类
2.  子类重写父类方法
3.  父类引用指向子类对象

#### 1.4.4 多态中两种类型转换 ####

1.  向上转型–自动类型转换

//Dog转Animal
    Animal animal = new Dog();
    
    //或者
    Dog dog = new Dog();
    Animal animal = dog;

1.  向下转型–强制类型转换

*  先使用instanceof关键字判断

Animal animal = new Dog();
    //Animal animal = new Cat();
    if(animal instanceof Dog){ 
    	Dog dog = (Dog)animal
    	dog.play();
    }
    if(animal instanceof Cat){ 
    	Cat cat = (Cat)animal
    	cat.catching();
    }

#### 1.4.5 final 关键字 ####

1.  final修饰的类不能被继承
2.  final修饰的方法不能重写
3.  final和static同时修饰的字段为常量，一般大写
    
        private static final String ENTITY_NAME = "phoneSalePoints";
4.  final修饰成员变量、局部变量初始化后不能修改。
5.  final修饰的形参不能在方法中赋值

## 1.5 抽象类和接口 ##

#### 1.5.1 abstract 抽象类 ####

1.  抽象方法：使用**abstract**修饰的方法, 只有方法的声明部分,没有方法体
2.  子类继承了抽象类, 子类需要重写抽象类所有的抽象方法
3.  ==面向抽象编程：==上层代码只定义规范（例如：**abstract class Person**），具体的业务逻辑由不同的子类实现，调用者并不关心

public class Main { 
        public static void main(String[] args) { 
            Person p = new Student();
            p.run();
        }
    }
    
    abstract class Person { 
        public abstract void run();	//抽象方法
    }
    
    class Student extends Person { 
        @Override
        public void run() { 
            System.out.println("Student.run");
        }
    }

#### 1.5.2 interface 接口 ####

抽象类与接口比较

<table> 
 <thead> 
  <tr> 
   <th align="center"></th> 
   <th align="center">abstract class</th> 
   <th align="center">interface</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">继承</td> 
   <td align="center">只能<strong>extends</strong>一个class</td> 
   <td align="center">可以<strong>implements</strong>多个<strong>interface</strong></td> 
  </tr> 
  <tr> 
   <td align="center">属性</td> 
   <td align="center">可以定义成员变量</td> 
   <td align="center">不能定义成员变量</td> 
  </tr> 
  <tr> 
   <td align="center">抽象方法</td> 
   <td align="center">可以定义</td> 
   <td align="center">可以定义</td> 
  </tr> 
  <tr> 
   <td align="center">非抽象方法</td> 
   <td align="center">不能定义</td> 
   <td align="center">可以定义<strong>default</strong>方法</td> 
  </tr> 
 </tbody> 
</table>

**default**方法：实现这个接口的类不必须重写的方法，需要再重写

*  接口和接口中的方法前面都省略了**abstract**

--------------------

# 2. java核心类 #

## 2.1 字符串 ##

*  Java字符串**String**是不可变对象，字符串操作不改变原字符串内容，而是返回新字符串；

#### 2.1.1 比较使用==和equals ####

*  在编译期会把所有相同的字符串当作一个对象放在常量池中
 *  == 是直接比较的两个对象的堆内存地址（比较的是两个引用类型的变量是否是同一个对象）
 *  **equals**（**equalsIgnoreCase**方法-忽略大小写比较）判断的是具体内容

//编译期"hello"和"HELLO"都在常量池中，"HELLO".toLowerCase()之后返回的新字符串"hello"放在堆中，地址不同
    String s1 = "hello";
    String s2 = "HELLO".toLowerCase();
    System.out.println(s1 == s2);	//false
    System.out.println(s1.equals(s2));	//true

#### 2.1.2 String类提供的常用方法 ####

// 是否包含子串: contains()
    "Hello".contains("ll"); // true
    
    //搜索子串
    "Hello".indexOf("l"); // 2
    "Hello".lastIndexOf("l"); // 3
    "Hello".startsWith("He"); // true
    "Hello".endsWith("lo"); // true
    
    //提取子串 substring()
    "Hello".substring(2); // "llo"
    "Hello".substring(2, 4); "ll"
    
    //去除首尾空白 trim() 和 strip()
    " \tHello\r\n ".trim(); // "Hello" 不可去除中文空格字符\u3000
    "\u3000Hello\u3000".strip(); // "Hello" 可去除中文空格字符\u3000
    " Hello ".stripLeading(); // "Hello "
    " Hello ".stripTrailing(); // " Hello"
    
    //是否空 isEmpty() 和 isBlank()
    "".isEmpty(); // true，因为字符串长度为0 
    " ".isEmpty(); // false，因为字符串长度不为0 是否为空
    " \n".isBlank(); // true，因为只包含空白字符 是否为空白字符串
    " Hello ".isBlank(); // false，因为包含非空白字符
    
    //替换子串 replace()
    "Hello".replace('l', 'w'); // "hewwo"，所有字符'l'被替换为'w'
    "Hello".replace("ll", "~~"); // "he~~o"，所有子串"ll"被替换为"~~"
    
    //分割（结果是数组） split()
    String s = "A,B,C,D";
    String[] ss = s.split("\\,"); // {"A", "B", "C", "D"}
    
    String s = "A^B@C#D";
    String[] ss = s.split("\\^|@|#"); // {"A", "B", "C", "D"}
    
    //拼接字符串 join()
    String[] arr = { "A", "B", "C"};
    String s = String.join("***", arr); // "A***B***C"
    
    //类型转换
    //别类型转字符串
    String.valueOf(123); // "123"
    String.valueOf(45.67); // "45.67"
    String.valueOf(true); // "true"
    String.valueOf(new Object()); // 类似java.lang.Object@636be97c
    //字符串转int
    int n1 = Integer.parseInt("123"); // 123
    int n2 = Integer.parseInt("ff", 16); // 按十六进制转换，255
    //字符串转Boolean
    boolean b1 = Boolean.parseBoolean("true"); // true
    boolean b2 = Boolean.parseBoolean("FALSE"); // false

#### 2.1.3 StringBuilder ####

*  在拼接字符串时，每次循环都会创建新字符串对象，扔掉旧的字符串对象，很多都是临时对象，浪费内存。使用**StringBuilder**会分配缓冲区，不会创建临时对象，只输出最终的

StringBuilder sb = new StringBuilder(1024);
    sb.append("Mr ")
       .append("Bob")
       .append("!")
       .insert(0, "Hello, ");
    System.out.println(sb.toString());

*  **StringBuilder**是可变对象，用来拼接字符串。支持链式操作，每次返回本身**this**，然后接着往后追加。
 *  **StringBuffer**线程更安全，但效率低，极少用。

#### 2.1.4 StringJoiner ####

*  用分隔符拼接数组成字符串，可添加首尾

String[] names = { "Bob", "Alice", "Grace"};
    StringJoiner s = new StringJoiner(",","Hello ","!");
    for (String name : names) { 
    s.add(name);
    }
    System.out.println(s.toString());	//Hello Bob,Alice,Grace!

*  若不用添加首尾，直接使用**String.join()**

String[] names = { "Bob", "Alice", "Grace"};
    var s = String.join(", ", names);	//Bob,Alice,Grace

#### 2.1.5 包装类型 ####

*  **int** 基本类型数据转成引用类型数据**Integer**，**Integer**类就可以视为 **int** 的包装类。

1.  java核心库为每种基本类型都提供了对应的包装类型：

<table> 
 <thead> 
  <tr> 
   <th align="center">基本类型</th> 
   <th align="center">对应的引用类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">boolean</td> 
   <td align="center">java.lang.Boolean</td> 
  </tr> 
  <tr> 
   <td align="center">byte</td> 
   <td align="center">java.lang.Byte</td> 
  </tr> 
  <tr> 
   <td align="center">short</td> 
   <td align="center">java.lang.Short</td> 
  </tr> 
  <tr> 
   <td align="center">int</td> 
   <td align="center">java.lang.Integer</td> 
  </tr> 
  <tr> 
   <td align="center">long</td> 
   <td align="center">java.lang.Long</td> 
  </tr> 
  <tr> 
   <td align="center">float</td> 
   <td align="center">java.lang.Float</td> 
  </tr> 
  <tr> 
   <td align="center">double</td> 
   <td align="center">java.lang.Double</td> 
  </tr> 
  <tr> 
   <td align="center">char</td> 
   <td align="center">java.lang.Character</td> 
  </tr> 
 </tbody> 
</table>

1.  装箱、拆箱 和 自动装箱、自动拆箱

*  都发生在编译阶段

int i = 100;
    Integer n = Integer.valueOf(i);	//装箱
    int x = n.intValue();	//拆箱
    
    ------------------------------------------------------
    
    Integer n = 100; // 自动装箱：编译器自动使用Integer.valueOf(int)
    int x = n; // 自动拆箱：编译器自动使用Integer.intValue()

1.  自动拆箱可能会报空指针异常NullPointerException

Integer n = null;
    int i = n;

1.  包装类型是引用数据类型，比较必须使用**equals()**；
2.  整数和浮点数的包装类型都继承自**Number**；

// 向上转型为Number:
    Number num = new Integer(999);
    // 获取byte, int, long, float, double:
    byte b = num.byteValue();
    int n = num.intValue();
    long ln = num.longValue();
    float f = num.floatValue();
    double d = num.doubleValue();

#### 2.1.6 JavaBean ####

*  **JavaBean**是一种符合命名规范的**class**，它通过**getter**和**setter**来定义属性
 *  规范：  
    若干**private**实例字段；  
    通过**public**方法来读写实例字段

public class Person { 
        private String name;
        private int age;
    
        public String getName() {  return this.name; }
        public void setName(String name) {  this.name = name; }
    
        public int getAge() {  return this.age; }
        public void setAge(int age) {  this.age = age; }
    }

#### 2.1.7 枚举类 ####

public class Main { 
        public static void main(String[] args) { 
            Weekday day = Weekday.SUN;
            if (day == Weekday.SAT || day == Weekday.SUN) { 
                System.out.println("Work at home!");
            } else { 
                System.out.println("Work at office!");
            }
        }
    }
    
    enum Weekday { 
        SUN, MON, TUE, WED, THU, FRI, SAT;
    }

*  编译之后

//编译之后
    public final class Weekday extends Enum {  // 继承自Enum，标记为final class
        // 每个实例均为全局唯一:
        public static final Weekday SUN = new Weekday ();
        public static final Weekday MON = new Weekday ();
        public static final Weekday TUE = new Weekday ();
        // private构造方法，确保外部无法调用new操作符:
        private Weekday () { }
    }

*  使用 name() 返回常量名

String s = Weekday.SUN.name(); // "SUN"

#### 2.1.8 Math类 ####

Math类就是用来进行数学计算的，比如：绝对值、最大值、最小值、三角函数、对数等

*  其中生成一个**0 <= x < 1**的随机数

Math.random(); // 0.53907... 每次都不一样

--------------------

# 3. 集合 #

*  存放对象的容器
 *  集合分为单列集合(Collection)和双列集合（Map）

## 3.1 集合与数组对比 ##

<table> 
 <thead> 
  <tr> 
   <th align="center">数组</th> 
   <th align="center">集合</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">长度固定</td> 
   <td align="center">长度可变</td> 
  </tr> 
  <tr> 
   <td align="center">存放基本类型数据和对象</td> 
   <td align="center">存放对象，基本类型数据会自动装箱</td> 
  </tr> 
  <tr> 
   <td align="center">{1, 2, 3}</td> 
   <td align="center">[1, 2, 3]</td> 
  </tr> 
 </tbody> 
</table>

*  字符串与对象区别：

String x =  “abcd”
    String y = new String(“zbcd”);
    X 指向的是方法区中的字符串常量对象。
    Y 指向的是堆中的字符串对象，在堆中所产生的字符串对象，必须以方法区中的字符串常量对象为模板，将字符串常量对象的内容复制到堆中。
    
    所以 new String(“abcd”) 有可能产生两个对象，一个在堆中，一个在方法区中。

## 3.2 集合类的继承关系 ##

*  **list:** 有序、可重复、有索引
 *  **set:** LinkedHashSet有序、不重复、无索引
 *  **以下图片均为转载**：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70 3]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70 4]

## 3.3 Collection接口 和 Collections类 ##

*  **Collection接口**是单列集合最顶层的接口，定义了所有单列集合共性的方法，任意单列集合都可以使用

最前面是返回值类型
      ●   boolean add(Object e) 	把给定的对象添加到当前集合中
      ●   void clear() 				清空集合中所有的元素 
      ●   boolean remove(Object o) 	把给定的对象在当前集合中删除 
      ●   boolean contains(Object o) 判断当前集合中是否包含给定的对象 
      ●   boolean isEmpty() 	判断当前集合是否为空 
      ●   Iterator iterator() 	迭代器，用来遍历集合中的元素的 
      ●   int size() 			返回集合中元素的个数 
      ●   Object[] toArray() 	把集合中的元素，存储到数组中 
      ●   Iterator :  			迭代器 
      ●   Object next()			返回迭代的下一个元素 
      ●   boolean hasNext()		如果仍有元素可以迭代，则返回 true。
    
    ArrayList有的：
      ●   boolean addAll(Collection) 	把一个集合元素都添加到当前集合中  
      ●   Object get()		获取指定位置的对象
      ●   void set(index,Object)	替换
      ●   int indexOf()		获取对象所处的位置

*  **Collections类**是容器的工具类,就如同**Arrays**是数组的工具类。

<table> 
 <thead> 
  <tr> 
   <th align="center">方法名称</th> 
   <th align="center">实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">反转</td> 
   <td align="center">Collections.<strong>reverse</strong>(numbers);</td> 
  </tr> 
  <tr> 
   <td align="center">混淆</td> 
   <td align="center">Collections.<strong>shuffle</strong>(numbers);</td> 
  </tr> 
  <tr> 
   <td align="center">排序</td> 
   <td align="center">Collections.<strong>sort</strong>(numbers);</td> 
  </tr> 
  <tr> 
   <td align="center">交换</td> 
   <td align="center">Collections.<strong>swap</strong>(numbers,0,5);</td> 
  </tr> 
  <tr> 
   <td align="center">滚动</td> 
   <td align="center">Collections.<strong>rotate</strong>(numbers,2); 例：[1, 2, 3, 4, 5]–&gt;[4, 5, 1, 2, 3 ]</td> 
  </tr> 
  <tr> 
   <td align="center">非线程安全转线程安全</td> 
   <td align="center">Collections.<strong>synchronizedList</strong>(numbers);</td> 
  </tr> 
 </tbody> 
</table>

## 3.4 ArrayList和List ##

*  源码

public class ArrayList<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable

**ArrayList**实现了**java.util.List**接口

List heros = new ArrayList();	//多态，接口引用指向子类对象

## 3.5 泛型 Generic ##

*  不指定泛型的容器，可以存放任何类型的元素
 *  指定了泛型的容器，只能存放指定类型的元素以及其子类

List genericheros = new ArrayList();
    List<Hero> genericheros = new ArrayList<Hero>();

*  使用泛型，可以在一个**ArrayList**中放两种不同的对象，其余对象都不能放（题目）。

创建一个父类，让两个类都继承，然后ArrayList指定泛型为这个父类

//让 Student类、Teacher类都继承 Person类
    List<Person> people = new ArrayList<Person>();
    people.add(new Student("zhangsan",18));
    people.add(new Teacher("wanglaoshi"));
    for (Person everyone : people) { 
        System.out.println(everyone );
    }

## 3.6 三种循环 ##

#### 3.6.1 迭代器 Iterator ####

*  原理：**Collection**集合中元素的通用获取方式。取元素前先判断有没有，有则取；再判断，再取；直到把所有元素取出来

Collection<String> list = new ArrayList<>(); //创建集合
    Iterator<String> it = list.iterator();  //使用iterator()方法获取迭代器对象.
    while(it.hasNext()){   // hasNext()判断是否有下一个元素
         String str = it.next();  // 取出集合中下一个元素.
    }

*  使用迭代器 **remove**集合中的对象

//迭代器删除Integer
    List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    
    Iterator<Integer> it = list.iterator();
    while (it.hasNext()) { 
        Integer a = it.next();
        if (a > 3) { 
            it.remove();
        }
    }
    
    for (Integer i : list) { 
        System.out.print(i);
    }
    // 结果：1 2 3

#### 3.6.2 for 循环 ####

*  注意：

1.  数组有**length**属性
2.  **String**有 length( ) 方法
3.  集合使用 size( ) 方法

//1.
    int[] a={ 1,2,3};
    System.out.println(a.length);
    
    //2.
    String s="hahah";
    System.out.println(s.length());
    
    //3.
    for (int i = 0; i < heros.size(); i++) { 
       Hero h = heros.get(i);
        System.out.println(h);
    }

#### 3.6.3 增强型 for 循环 ####

*  不体现索引

List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    for (Integer i : list) { 
    	System.out.println(i);
    }

## 3.7 LinkedList ##

#### 3.7.1 概念 FIFO 和 FILO ####

FIFO：先进先出，在Java中又叫 Queue 队列 
    FILO：先进后出，在Java中又叫 Stack 栈

#### 3.7.2 双向链表( 双端队列 ) Deque ####

*  **LinkedList**除了实现**List**接口外，还实现了双向链表结构**Deque**，方便在头尾插入和删除数据
 *  源码：

public class LinkedList<E>
         extends AbstractSequentialList<E>
         implements List<E>, Deque<E>, Cloneable, java.io.Serializable

public interface Deque<E> extends Queue<E> {

*  **链表结构**： 与数组结构相比较，数组结构，就好像是电影院，每个位置都有标示，每个位置之间的间隔都是一样的。 而链表就相当于佛珠，每个珠子，只连接前一个和后一个，不用关心除此之外的其他佛珠在哪里。
 *  举例：  
    注意：双向链表主要是使用**Deque**接口，所以创建对象的时候可以使用**Deque**接口引用指向子类**LinkedList**对象。不能使用**List**接口，否则需要强转。

//链表结构
    LinkedList<Arms> ll = new LinkedList<Arms>();
     //Deque可以
     //Deque<Arms> ll = new LinkedList<Arms>();
     
     //List需强转
     //List<Arms> ll1 = new LinkedList<Arms>();
     //((LinkedList<Arms>) ll).addLast(new Arms("duolanjian"));
    
     ll.addLast(new Arms("duolanjian"));
     ll.addLast(new Arms("duolandun"));
     ll.addFirst(new Arms("duolanjie"));
     for (Arms everyArms : ll) { 
         System.out.println(everyArms);
     }
     // name:duolanjie
     // name:duolanjian
     // name:duolandun
     
     ll.removeFirst();
     // name:duolanjian
     // name:duolandun
     ll.removeLast();
     // name:duolanjian

#### 3.7.3 队列 Queue ####

*  常用方法  
    **offer** 在最后添加元素  
    **poll** 取出第一个元素  
    **peek** 查看第一个元素

//队列
    //offer 在最后添加元素
    //poll 取出第一个元素
    //peek 查看第一个元素
    Queue<Arms> q = new LinkedList<Arms>();
    q.offer(new Arms("pobai"));
    q.offer(new Arms("lvcha"));
    q.offer(new Arms("huopao"));
    Arms p = q.peek();  //查看 name:pobai
    q.poll();   //取 [name:lvcha, name:huopao]
    System.out.println(p);
    System.out.println(q);

#### 3.7.4 队列 Queue 和 双端队列 Deque 对比 ####

<table> 
 <thead> 
  <tr> 
   <th align="center">队列</th> 
   <th align="center">双端队列</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">Queue</td> 
   <td align="center">Deque</td> 
  </tr> 
  <tr> 
   <td align="center">add</td> 
   <td align="center">addFirst / addLast (下同)</td> 
  </tr> 
  <tr> 
   <td align="center">offer</td> 
   <td align="center">offerFirst 添加</td> 
  </tr> 
  <tr> 
   <td align="center">remove</td> 
   <td align="center">removeFirst 删除首位（集合为空抛异常）</td> 
  </tr> 
  <tr> 
   <td align="center">poll</td> 
   <td align="center">pollFirst 取出首位（集合为空为null）</td> 
  </tr> 
  <tr> 
   <td align="center">element</td> 
   <td align="center">getFirst</td> 
  </tr> 
  <tr> 
   <td align="center">peek</td> 
   <td align="center">peekFirst 查看</td> 
  </tr> 
 </tbody> 
</table>

*  使用**LinkedList**实现**Stack**栈（先入后出）

/** * ClassName:MyStack * Description:使用LinkedList实现Stack栈 */
    public class MyStack { 
        private static LinkedList<Arms> list = new LinkedList<>();
    
        //进栈方法
        public void push(Arms a){ 
            list.offerLast(a);
        }
    
        //出栈方法
        public void pull(){ 
            list.pollLast();
        }
    
        public static void main(String[] args) { 
    
            MyStack stack = new MyStack();
            System.out.println("当前栈内元素："+ list);
            for (int i = 0; i < 5; i++) { 
                stack.push(new Arms("arms" + i));
                System.out.println("入栈" + list);
            }
    
            for (int i = 0; i < 5; i++) { 
                stack.pull();
                System.out.println("出栈" + list);
            }
        }
    }

运行结果：
    当前栈内元素：[]
    入栈[name:arms0]
    入栈[name:arms0, name:arms1]
    入栈[name:arms0, name:arms1, name:arms2]
    入栈[name:arms0, name:arms1, name:arms2, name:arms3]
    入栈[name:arms0, name:arms1, name:arms2, name:arms3, name:arms4]
    出栈[name:arms0, name:arms1, name:arms2, name:arms3]
    出栈[name:arms0, name:arms1, name:arms2]
    出栈[name:arms0, name:arms1]
    出栈[name:arms0]
    出栈[]

#### 3.7.5 ArrayList 和 LinkedList 的对比 ####

<table> 
 <thead> 
  <tr> 
   <th align="center"></th> 
   <th align="center">ArrayList</th> 
   <th align="center">LinkedList</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">定位（查）</td> 
   <td align="center">快</td> 
   <td align="center">慢</td> 
  </tr> 
  <tr> 
   <td align="center">插入删除数据（增删）</td> 
   <td align="center">慢</td> 
   <td align="center">快</td> 
  </tr> 
  <tr> 
   <td align="center">底层</td> 
   <td align="center">数组</td> 
   <td align="center">双向链表</td> 
  </tr> 
 </tbody> 
</table>

*  **ArrayList**是顺序结构，所以定位很快，指哪找哪。 就像电影院位置一样，有了电影票，一下就找到位置了。
 *  **LinkedList** 是链表结构，就像手里的一串佛珠，要找出第99个佛珠，必须得一个一个的数过去，所以定位慢

比较 ArrayList和LinkedList, 在最后面插入100000条数据,谁快谁慢？
    答：一样快。因为是插入在最后面，所以对于数组而言，并没有一个移动很多数据的需要，所以也非常的快

在List的中间位置，插入10000条数据，比较ArrayList快，还是LinkedList快，并解释为什么？
    答：在这个位置插入数据时
    	数组定位很快，插入数据比较慢
    	链表定位很慢，插入数据比较快
    	最后发现，当总数是10000条的时候，链表定位的总开支要比数组插入的总开支更多，所以最后整体表现，数组会更好。

--------------------

## 3.8 二叉树 ##

#### 3.8.1 概念 ####

二叉树由各种节点组成

*  特点：  
    每个节点都可以有左子节点，右子节点  
    每一个节点都有一个值

#### 3.8.2 排序插入数据 ####

*  示意图来自：how2j.cn

使用二叉树对 {67,7,30,73,10,0,78,81,10,74} 排序

*  原理：小、相同的放左边，大的放右边

1. 67 放在根节点
    2. 7 比 67小，放在67的左节点
    3. 30 比67 小，找到67的左节点7，30比7大，就放在7的右节点
    4. 73 比67大， 放在67的右节点

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70 5]

*  使用二叉树排序，组装成List形式输出从小到大的一组数据

public class Node { 
        // 左子节点
        public Node leftNode;
        // 右子节点
        public Node rightNode;
    
        // 值
        public Object value;
    
        // 插入 数据
        public void add(Object v) { 
            // 如果当前节点没有值，就把数据放在当前节点上
            if (null == value) { 
                value = v;
    		}
            // 如果当前节点有值，就进行判断，新增的值与当前值的大小关系
            else { 
                // 新增的值，比当前值小或者相同
                if ((Integer) v -((Integer)value) <= 0) { 
                    if (null == leftNode) { 
                        leftNode = new Node();
                    }
                    leftNode.add(v);
                }
                // 新增的值，比当前值大
                else { 
                    if (null == rightNode) { 
                        rightNode = new Node();
                    }
                    rightNode.add(v);
                }
            }
        }
    
        // 中序遍历所有的节点组成常见的List形式
        public List<Object> values() { 
            List<Object> values = new ArrayList<>();
            // 右节点的遍历结果
            if (null != rightNode) { 
                values.addAll(rightNode.values());
    		}
            // 当前节点
            values.add(value);
            // 左节点的遍历结果
            if (null != leftNode) { 
                values.addAll(leftNode.values());
            }
            return values;
        }
    
        public static void main(String[] args) { 
            int randoms[] = new int[] {  67, 7, 30, 73, 10, 0, 78, 81, 10, 74 };
            Node roots = new Node();
            for (int number : randoms) { 
                roots.add(number);
            }
            System.out.println(roots.values());
            //[0, 7, 10, 10, 30, 67, 73, 74, 78, 81] 先遍历左节点为顺序
            //[81, 78, 74, 73, 67, 30, 10, 10, 7, 0] 先遍历右节点为倒序
        }
    }

*  二叉树刚插完数据的结构  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70 6]

#### 3.8.3 选择法、冒泡法、二叉树 三种排序性能区别 ####

选择法：	第一个与之后每一个比较，比其小交换位置
    冒泡法：	两个相邻的比较，左大右小时，交换位置
    二叉树：	第一个数放中间，小、相同的放左边，大的放右边

*  结论：二叉树最快

初始化一个长度是40000的随机数字的数组
    初始化完毕
    接下来分别用3种算法进行排序
    选择法排序，一共耗时 6865 毫秒
    冒泡法排序，一共耗时 4388 毫秒
    二叉树排序，一共耗时 84 毫秒

## 3.9 HashMap、Hashtable、HashSet 和hashcode ##

#### 3.9.1 HashMap ####

*  **HashMap**属于双列集合，储存数据的方式是：键值对，键不能重复，值可重复。（若键重复，后面的值会覆盖前面的值）可以存放null，线程不安全。

#### 3.9.2 Hashtable ####

*  **Hashtable**同**HashMap**，但不能存放null，线程安全。

#### 3.9.3 HashSet ####

*  **HashSet**同属于单列集合，无序不可重复。

HashSet自身并没有独立的实现，而是在里面封装了一个Map.
    HashSet是作为Map的key而存在的
    而value是一个命名为PRESENT的static的Object对象，因为是一个类属性，所以只会有一个。
    private static final Object PRESENT = new Object();

#### 3.9.4 hashcode ####

*  **hashcode**相当于字典的页码，先确定大概位置，再详细对比。  
    比如有一个对象，**hashcode**值为1001，保存时，存在一个数组1001的索引位置上，如果该位置没有其他对象，直接保存；如果已经有其他对象，就创建一个链表往后追加。  
    查询时，直接用**hashcode**定位到该索引位置，然后依次使用**equals**对比才位置对象。比起**list**全部循环一遍查找，大大提高了查询效率。  
    示意图来自：how2j  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70 7]

## 3.10 HashSet、LinkedHashSet 、TreeSet ##

*  **HashSet**： 无序
 *  **LinkedHashSet**： 按照插入顺序
 *  **TreeSet**： 从小到大排序
 *  都不重复

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191117212857714.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191117222434462.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191123204830939.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0,size_16,color_FFFFFF,t_70
[Link 1]: https://www.cnblogs.com/zerahmu/p/7662810.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191219153611667.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/2019121915362618.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20191219171454739.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20191219172435824.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20191225145036547.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5NDA1NTgwMzY0,size_16,color_FFFFFF,t_70