swzxsyh

--笔记

0%

发表于 更新于

一.Map集合
1.1 Map的概述以及特点
什么是Map集合：
Collection集合称为单列集合，Map集合称为双列集合，key-value，键-值，名称：Entry
Map集合的特点：
a.Collection每个元素单独存在(单列)，Map每个元素成对存在(双列)
b.Map集合中，键必须是唯一的，值是可以重复的
c.Collection中，泛型只有一个。Map<K,V>中，泛型有两个(其中K代表键Key的类，V代表值Value类)

1.2 Map的3个常用实现类以及其特点
Map接口有三个常见的实现类：
HashMap<K,V>:
底层采用哈希表结构
无序

LinkedHashMap<K,V>:
底层采用链表+哈希表结构
有序

TreeMap<K,V>:
底层采用红黑树结构
无序，键有自然顺序的，即按照键的自然顺序输出

重点：Map中为了保证键的唯一性，如果键是自定义类型，必须重写键的hashCode和equals方法

1.3 Map接口中定义的通用方法
增:public V put(K key, V value) ;添加一个键值对Entry，返回null
删:public V remove(Object key);根据键Key去删键值对Entry，返回被删除的键值对的值
查:public V get(Object key);根据键Key获取对应的值Value
改:public V put(K key, V value) ;添加一个重复的键时，该方法变为修改，返回修改前的值
其他:
public boolean containKey(Object K);判断Map中是否包含该键
public boolean containKey(Object V);判断Map中是否包含该值

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
public static void main(String[] args) {
  HashMap<String ,Integer> map = new HashMap<String,Integer>();
  //增加
  map.put("a",1);
  map.put("b",2);
  map.put("c",3);
  map.put("d",4);
  map.put("e",5);
  map.put("f",6);
  System.out.println(map);
  //删除
  Integer v1 = map.remove("a");
  System.out.println(v1);
  System.out.println(map);
  //删除不存在的v
  Integer v2 = map.remove("g");
  System.out.println(v2);
  System.out.println(map);
  //获取
  Integer v3 = map.get("a");
  System.out.println(v3);
  System.out.println(map);
  //修改也是调用put
  Integer v4 = map.put("c", 12);
  System.out.println(v4);
  System.out.println(map);
  //判断
  boolean k = map.containsKey("a");
  System.out.println(k);
  boolean v = map.containsValue(5);
  System.out.println(v);
}

1.4 Map的遍历
•遍历方式一：以键找值
public Set keySet() : 获取Map集合中所有的键，存储到Set集合中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void main(String[] args) {
  HashMap<String, Integer> map = new HashMap<String, Integer>();
  //增加
  map.put("a", 1);
  map.put("b", 2);
  map.put("c", 3);
  map.put("d", 4);
  map.put("e", 5);
  map.put("f", 6);
  Set<String> keys = map.keySet();
  for (String key : keys) {
    Integer value = map.get(key);
    System.out.println(key);
    System.out.println(value);
  }
}

•遍历方式二:键值对方式
public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static void main(String[] args) {
  HashMap<String, Integer> map = new HashMap<String, Integer>();
  //增加
  map.put("a", 1);
  map.put("b", 2);
  map.put("c", 3);
  map.put("d", 4);
  map.put("e", 5);
  map.put("f", 6);
  //Map集合遍历的第二种方式：键值对方式
  //获取所有键值对
  Set<Map.Entry<String, Integer>> entries = map.entrySet();
  //遍历entrys集合
  for (Map.Entry<String, Integer> entry : entries) {
    //从entry种取出键值
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println(key+"..."+value);
  }
}

1.5 HashMap存储自定义类型的键
需求：创建一个Map，学生为键，家庭地址作值。

学生键：

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
public class Student {
  String Name;
  int age;
  public Student(){

  }

  @Override
  public String toString() {
    return "Student{" +
      "Name='" + Name + '\'' +
      ", age=" + age +
      '}';
  }

  public Student(String name, int age) {
    Name = name;
    this.age = age;
  }
  //为了保证学生键的唯一性，要重写hashCode和equals
  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }
    Student student = (Student) o;
    return age == student.age &&
      Objects.equals(Name, student.Name);
  }

  @Override
  public int hashCode() {
    return Objects.hash(Name, age);
  }
}

测试Demo：

1
2
3
4
5
6
7
8
9
10
11

public static void main(String[] args) {
  HashMap<Student,String >  std= new HashMap<Student,String>();
  std.put(new Student("a",1), "PK");
  std.put(new Student("b",2), "GZ");
  std.put(new Student("c",3), "SH");
  std.put(new Student("d",4), "SZ");
  System.out.println(std);
  std.put(new Student("b",2), "SC");
  System.out.println(std);
}

结论：如果键是自定义类型，那么为了保证键的唯一性，必须重写hashCode和equals方法

1.6 LinkedHashMap介绍
HashMap底层采用哈希表结构，所以无序
LinkedHashMap底层采用的是链表结构+哈希表，所以是有序的

1
2
3
4
5
6
7
8
9
public static void main(String[] args) {
  LinkedHashMap<String ,Integer> LHS = new LinkedHashMap<String ,Integer>();
  LHS.put("a", 1);
  LHS.put("c", 1);
  LHS.put("d", 1);
  LHS.put("b", 1);

  System.out.println(LHS);
}

1.7 TreeMap集合
TreeMap底层采用的是红黑树结构，无序的，但是会以键的自然顺序输出

1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) {
  TreeMap<String ,Integer> TM = new TreeMap<String,Integer>();
  TM.put("a", 1);
  TM.put("c", 2);
  TM.put("e", 3);
  TM.put("d", 4);
  TM.put("b", 5);

  System.out.println(TM);
}

扩展：
如果键是数值类型，那么按照数值的大小升序
如果键是Character类型，那么按照字母的码值排序
如果键是String类型，那么按照字母首字母排序，若一样，次字母排序，依次类推
这四种结论是一样的：Arrays.sort() Collections.sort() TreeSet TreeMap

我们也可以使用比较器排序

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

public static void main(String[] args) {
  TreeMap<String, Integer> TM = new TreeMap<String, Integer>();
  TM.put("a", 1);
  TM.put("c", 2);
  TM.put("e", 3);
  TM.put("d", 4);
  TM.put("b", 5);

  System.out.println(TM);

  TreeMap<Integer, String> new_TM = new TreeMap<Integer, String>(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
      return o2 - o1;
    }
  });
  new_TM.put(1, "a");
  new_TM.put(3, "a");
  new_TM.put(2, "a");
  new_TM.put(5, "a");
  new_TM.put(4, "a");

  System.out.println(new_TM);
  TreeMap<Student, String> std = new TreeMap<Student, String>(new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
      return o2.Name.length() - o1.Name.length();
    }
  });

  std.put(new Student("aa", 1), "PK");
  std.put(new Student("bbb", 2), "GZ");
  std.put(new Student("cc", 3), "SH");
  std.put(new Student("ddddd", 4), "SZ");

  System.out.println(std);
}

1.8 Map集合练习
输入一个字符串，统计字符串中每个字符出现的次数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static void main(String[] args) {
  //定义一个Map
  LinkedHashMap<Character, Integer> LHM = new LinkedHashMap<Character, Integer>();
  //输入一个字符串
  System.out.println("input char");
  String str = new Scanner(System.in).nextLine();
  //遍历字符串
  for (int i = 0; i < str.length(); i++) {
    //           取出字符串中的某个字符
    char ch = str.charAt(i);
    //这个字符ch以前出现过
    if (LHM.containsKey(ch)) {
      Integer oldCount = LHM.get(ch);
      LHM.put(ch, oldCount + 1);
    } else {
      LHM.put(ch, 1);
    }
  }
  System.out.println(LHM);
}

二.集合的嵌套
什么是集合嵌套
集合中的元素还是一个集合

2.1 List嵌套list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static void main(String[] args) {
  ArrayList<String> class1 = new ArrayList<String>();
  Collections.addAll(class1, "a", "b", "c");

  ArrayList<String> class2 = new ArrayList<String>();
  Collections.addAll(class2, "e", "f", "g");

  //        将class1和class2保存到一个大集合中
  ArrayList<ArrayList<String>> classAll = new ArrayList<ArrayList<String>>();

  Collections.addAll(classAll, class1, class2);

  for (ArrayList<String> className : classAll) {
    for (String name:className
        ) {
      System.out.println(name);
    }
    System.out.println(className);
  }
}

2.2 List嵌套Map
a.保存两个班学生的姓名以及对应的年龄

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

public static void main(String[] args) {
  HashMap<String, Integer> class1 = new HashMap<String, Integer>();
  class1.put("a", 12);
  class1.put("b", 11);
  class1.put("c", 13);
  class1.put("d", 14);
  class1.put("e", 18);
  HashMap<String, Integer> class2 = new HashMap<String, Integer>();
  class2.put("f", 19);
  class2.put("g", 17);
  class2.put("h", 16);
  class2.put("i", 15);
  class2.put("k", 14);

  ArrayList<HashMap<String, Integer>> classAll = new ArrayList<HashMap<String, Integer>>();
  classAll.add(class1);
  classAll.add(class2);

  System.out.println(classAll);

  for (HashMap<String, Integer> className : classAll
      ) {
    Set<String> keys = className.keySet();
    for (String key : keys) {
      System.out.println(key);
    }
    System.out.println(className);
  }
}

2.3 Map嵌套Map
a.保存两个班的名字，和班里的同学的姓名，以及对应的年龄

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

public static void main(String[] args) {
  HashMap<String, Integer> class1 = new HashMap<String, Integer>();
  class1.put("a", 12);
  class1.put("b", 11);
  class1.put("c", 13);
  class1.put("d", 14);
  class1.put("e", 18);
  HashMap<String, Integer> class2 = new HashMap<String, Integer>();
  class2.put("f", 19);
  class2.put("g", 17);
  class2.put("h", 16);
  class2.put("i", 15);
  class2.put("k", 14);

  //将两个班级的Map集合保存到另一个集合中，要求有该班级的名字
  HashMap<String, HashMap<String, Integer>> classAll = new HashMap<String, HashMap<String, Integer>>();

  classAll.put("class one", class1);
  classAll.put("class two", class2);

  System.out.println(classAll);

  //获取所有的键
  Set<String> names = classAll.keySet();

  System.out.println(names);
  //遍历所有的键
  for (String name : names) {
    //以值找值
    HashMap<String, Integer> map = classAll.get(name);
    //获取map所有的键
    System.out.println(map);
    Set<String> ns = map.keySet();
    for (String n : ns
        ) {
      Integer value = map.get(n);
      System.out.println(n + "..." + value);
    }
  }
}

.模拟斗地主洗牌发牌
3.1 案例介绍
3.2 案例分析
斗地主要想办法自定义排序规则
核心思想：给斗地主中每一张牌，准备一个编号
a.不能出现相同的编号
b.牌越大，编号越大

I.准备编号和牌组成的Map集合
II.准备54个编号（一副牌）
III.洗牌（打乱集合）
V.发牌（遍历集合）
IV.对编号排序（sort）
IIV.转牌（以键找值map.get）
IIIV.打印给用户（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
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
69
70
71
72
73

public static void main(String[] args) {
  //        I.准备编号和牌组成的Map集合
  LinkedHashMap<Integer, String> Map = new LinkedHashMap<Integer, String>();

  //a.花色4种
  String[] colors = {"黑桃♠️", "红桃♥️", "梅花♣️", "方片♦️"};
  //b.数值13种
  String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "K", "Q", "A", "2"};
  //c.组合拍
  int id = 1;
  for (String num : numbers) {
    for (String color : colors) {
      String card = color + num;
      //                for ( i < num.length(); i++) {
      Map.put(id, card);
      id++;
    }
  }
  Map.put(53, "小王");
  Map.put(54, "大王");

  //        II.准备54个编号（一副牌）
  ArrayList<Integer> Cards = new ArrayList<Integer>();
  for (int i = 1; i < 55; i++) {
    Cards.add(i);
  }
  //        III.洗牌（打乱集合）
  Collections.shuffle(Cards);

  //        V.发牌（遍历集合）
  ArrayList<Integer> player1 = new ArrayList<Integer>();
  ArrayList<Integer> player2 = new ArrayList<Integer>();
  ArrayList<Integer> player3 = new ArrayList<Integer>();
  ArrayList<Integer> Holo_Card = new ArrayList<Integer>();

  //        IV.对编号排序（sort）
  //此处不能使用增强for
  for (int i = 0; i < Cards.size()-3; i++) {
    Integer Card = Cards.get(i);
    if (i % 3 == 0) {
      player1.add(Card);
    } else if (i % 3 == 1) {
      player2.add(Card);
    } else {
      player3.add(Card);
    }
  }
  //最后3张给底牌
  Holo_Card.add(Cards.get(53));
  Holo_Card.add(Cards.get(52));
  Holo_Card.add(Cards.get(51));

  Collections.sort(player1);
  Collections.sort(player2);
  Collections.sort(player3);
  Collections.sort(Holo_Card);

  //        IIV.转牌（以键找值map.get）
  //        IIIV.打印给用户（println）
  lookCards(player1, Map);
  lookCards(player2, Map);
  lookCards(player3, Map);
  lookCards(Holo_Card, Map);
}

public static void lookCards(ArrayList<Integer> idCards, LinkedHashMap<Integer, String> Map) {
  for (Integer idCard : idCards) {
    String card = Map.get(idCard);
    System.out.println(card + "");
  }
  System.out.println();
}

3.3 代码实现

三.冒泡排序
排序:将一组数据按照固定的规则进行排列

3.1 冒泡排序的介绍
所谓的冒泡排序的思想：
依次比较数组/集合中相连的两个元素，然后将较大的元素放在后面，最后按照从小到大的顺序排列出来
规律：
•如果有n个数进行排序比较，那么比较次数为n-1轮
•每轮比较完毕，下一轮比较就会少一个数据参与

4.2 冒泡排序过程图解

3.3 代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String[] args) {
  int[] arr = {4, 6, 1, 3, 82, 9, 7, 5};
  //外层循环，控制循环次数
  for (int i = 0; i < arr.length - 1; i++) {
    //内层循环，控制比较次数
    for (int j = 0; j < arr.length - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        int temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
  System.out.println(Arrays.toString(arr));
}

总结：
1.Map接口中定义对通用方法*
put(K,V);
remove(K);
get(K)
put(repeat K,V)
containsKey(K)
containsValue(V)

2.Map各种实现类对遍历方式(以键找值，键值对)*
a.以键找值
set keys = map.kepSet();
for(K key:keys){//遍历所有的键
//以键找值
V value = map.get(key);
sout(key,value);
}

b.键值对
set<Map.Entry<K,V>> entrys = map.entrySet();//获取所有的键值对集合
for(Map.Entry<K,V> entry:entrys)//遍历键值对集合
{
K key = entry.getKey();//获取键值中对键和值
V value = entry.getValue();//获取键值中对键和值
sout(key,value);
}
3.集合嵌套
a.List套list
ArrayList arr;

b.List套Map
ArrayList<HashMap<String,Integet>> arr;

c.Map套map
HashMap<String,HashMap<String,Integer>> map;

4.斗地主案例*

5.冒泡排序
a.冒泡过程
b.算法背下来

1
2
3
4
5
6
7
8
for(int i=0;i<arr.lenth-1;i++){
  for(int j=0;j<arr.lenth-1-i;j++){
    if(arr[j]>arr[j+i]){
      int temp=arr[j];
      arr[j]=arr[j+1]
        arr[j+1]=temp;
    }}
}

发表于 更新于

一.List接口
1.1 List接口的特点
a.List接口 继承 Collection接口
b.List接口的特点：
有序的（Java中的有序不是指自然顺序，而是指存取元素的顺序是一致的，什么顺序存就怎么取）
有索引的
元素可重复的(存储的元素可以重复)

1.2 List接口中常用的方法以及常用实现类
a.List接口继承Collection接口，所以已经有了collection中的8个（7个常见+iterator）
b.List接口还有自己的特有方法（4个）：
增：add(int index,E e)
删：remove(int index,E e)
改：set(int index,E e)
查：get(int index,E e)
c.List接口有哪些实现类
ArrayList[]
LinkedList[]
Vector[]

1.3 ArrayList的数据结构以及使用
a.ArrayList集合的方法(7个collection+1个迭代器+4个List接口中的)
特有方法：无
b.ArrayList集合底层采用的是数组结构，特点：查改快，增删慢
c.使用ArrayList

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void main(String[] args) {
  ArrayList<String> arr = new ArrayList<String>();
  arr.add("Java1" );
  arr.add("Java2" );
  arr.add("Java3" );
  arr.add(2, "99");
  System.out.println(arr);

  arr.remove(3);
  System.out.println(arr);

  arr.set(1, "11");
  System.out.println(arr);

  System.out.println(arr.get(2));
}

List的并发修改异常
并发修改异常：ConcurrentModificationException
•ConcurrentModificationException
产生原因：
•迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成类迭代器获取元素中判断欲求修改值和实际修改值不一致
解决方案：
•用for循环遍历，然后用集合对象做对应的操作即可(get方法)

ListIterator：列表迭代器
•通过List集合的listIterator()方法得到，它是List集合特有的迭代器
•用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

ListIterator中的常用方法
•E next();返回迭代中的下一个元素
•boolean hasNext();如果迭代器具有更多元素，则返回true
•E previous();返回迭代中的上一个元素
•boolean hasPrevious();如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
•void add(E e);将指定的元素插入列表

1.4 LinkedList的数据结构以及使用
a.LinkedList的方法(7个collection+1个迭代器+4个List接口中的)
有特有方法：
public void addFirst(E e);//添加元素到集合首
public void addLast(E e);//添加元素到集合尾
public E getFirst(E e);//获取集合的首元素
public E getLast(E e);//获取集合的尾元素
public E removeFirst(E e);//删除集合的首元素
public E removeLast(E e);//删除集合的尾元素

public void pop(E e);//删除集合中的首元素，底层就是removeFirst
public void push(E e);//添加集合中的首元素，底层就是addFirst
源码：

1
2
3
4
5
6
7
public E pop() {
  return removeFirst();
}

public void push(E e) {
  addFirst(e);
}

b.LinkedList底层采用的是链表结构，特点：查改慢，增删快
c.使用LinkedList

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
LinkedList<String> list = new LinkedList<String >();
list.add("a");
list.add("b");
list.add("c");

System.out.println(list);

list.addFirst("1");
list.addLast("10");

System.out.println(list);

System.out.println(list.getFirst());
System.out.println(list.getLast());

list.removeFirst();
System.out.println(list);

list.removeLast();
System.out.println(list);

list.pop();
System.out.println(list);

list.push("2");
System.out.println(list);

1.5 LinkedList的源码分析
a.LinkedList底层采用的是链表结构（双向列表）

b.LinkedList这个类有两个成员变量
Node first;记录了开始结点
Node last;记录了结束结点

c.结点类Node，它是LinkedList的内部类

1
2
3
4
private static class Node<E> {
    E item;//该节点的数据域
    Node<E> next;//指针域，指向下一个结点
    Node<E> prev;//指针域，指向上一个结点

d.LinkedList的add方法
I.将新增的结点，添加到last之后
II.并且将size++，总元素个数加一

1
2
3
4
public boolean add(E e) {
    linkLast(e);
    return true;
}

e.LinkedList的get方法
I.先查找指定索引的结点，（从前往后找，从后往前找）
II.找到结点后，获取结点的数据栈，然后返回

完整版：
•LinkedList的成员变量源码分析:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class LinkedList<E> extends AbstractSequentialList<E>
  implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
  transient int size = 0;
  /**
     * 存储第一个节点的引用
     */
  transient Node<E> first;
  /**
     * 存储最后一个节点的引用
     */
  transient Node<E> last;
  //......
  //......
}

•LinkedList的内部类Node类源码分析:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class LinkedList<E> extends AbstractSequentialList<E>
  implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
  //......
  private static class Node<E> {
    E item;//被存储的对象
    Node<E> next;//下一个节点
    Node<E> prev;//前一个节点

    //构造方法
    Node(Node<E> prev, E element, Node<E> next) {
      this.item = element;
      this.next = next;
      this.prev = prev;
    }
  }
  //......
}

•LinkedList的add()方法源码分析:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public boolean add(E e) {
  linkLast(e);//调用linkLast()方法 
  return true;//永远返回true
}

void linkLast(E e) {
  final Node<E> l = last;//一个临时变量，存储最后一个节点
  final Node<E> newNode = new Node<>(l, e, null);//创建一个Node对象 
  last = newNode;//将新Node对象存储到last
  if (l == null)//如果没有最后一个元素，说明当前是第一个节点
    first = newNode;//将新节点存为第一个节点 else
  l.next = newNode;//否则不是第一个节点，就赋值到当前的last的next成员 
  size++;//总数量 + 1
  modCount++;//
}

•LinkedList的get()方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public E get(int index) {
  checkElementIndex(index);//检查索引的合法性(必须在0-size之间)，如果不合法，此方法抛出异常
  return node(index).item;
}

Node<E> node(int index) {//此方法接收一个索引，返回一个Node
  // assert isElementIndex(index);
  if (index < (size >> 1)) {//判断要查找的index是否小于size / 2，二分法查找
    Node<E> x = first;// x = 第一个节点——从前往后找
    for (int i = 0; i < index; i++)//从0开始，条件:i < index，此循环只控制次数
      x = x.next;//每次 x = 当前节点.next; 
    return x;//循环完毕，x就是index索引的节点。
  } else {
    Node<E> x = last;// x = 最后一个节点——从后往前找
    for (int i = size - 1; i > index; i--)//从最后位置开始，条件:i > index
      x = x.prev;//每次 x = 当前节点.prev; 
    return x;//循环完毕，x就是index索引的节点
  }
}

二.Collections类
2.1 Collections的介绍
Collections不是collection！
作用：Collections是一个集合的工具类，该类中有一堆静态方法，专门操作集合

2.2 Collections常用功能
public static void shuffle(List list);//随机打乱集合中元素的顺序 public static void sort(List list);//将集合中的元素进行升序排序

扩展：Collections的sort方法，默认是对集合中对元素进行升序排序
如果集合的泛型是数值类型，那么按照数值的大小升序
如果集合的泛型是Character类型，那么按照字母的码值排序
如果集合的泛型是String类型，那么按照字母首字母排序，若一样，次字母排序，依次类推
提示：Collections.sort方法结论和Array.sort()是一样的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static void main(String[] args) {
  ArrayList<Integer> arr = new ArrayList<Integer>();

  arr.add(1);
  arr.add(2);
  arr.add(3);
  arr.add(5);
  arr.add(9);
  arr.add(8);
  arr.add(7);
  arr.add(6);
  arr.add(4);

  System.out.println(arr);

  Collections.sort(arr);
  System.out.println(arr);

  Collections.shuffle(arr);
  System.out.println(arr);
}

2.3 Comparator比较器排序
Collections还有一个sort方法：
public static void sort(List list,Comparator com);带有比较器的排序方法
这个比较器源码：

1
2
3
public interface Comparator<T>{
  int compare(T o1, T o2);    
}

我们注意到Comparator实际上是一个接口，那么我们在调用sort方法时，需要传人一个该接口的实现类对象（匿名内部类）

降序排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Collections.sort(arr, new Comparator<Integer>() {
  /*该方法就是比较方法，它会把集合中每两个元素传入
    @param o1 第一个元素
    @param o2 第二个元素
    @return 返回值代表谁大谁小，如果是正数代表o1大，负数则代表o2大，如果0代表一样大

     口诀：升序前减后，降序后减前
     */

  @Override
  public int compare(Integer o1, Integer o2) {
    return o2-o1;//降序
    //return o1-o2; //升序

  }
});

自定义排序

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
public static void main(String[] args) {
  ArrayList<Dog> arr = new ArrayList<Dog>();

  arr.add(new Dog(1, "a", 4));
  arr.add(new Dog(2, "b", 2));
  arr.add(new Dog(3, "c", 3));
  arr.add(new Dog(4, "d", 2));

  Collections.sort(arr, new Comparator<Dog>() {
    @Override
    public int compare(Dog o1, Dog o2) {
      //按照年龄降序排序
      //                return o2.age - o1.age;
      //按照姓名升序排序
      //                return o1.name.length() - o2.name.length();
      //按照年龄和腿数总和升序
      return (o1.age+o1.legs_num)-(o2.age+o2.legs_num);

    }
  });

  for (Dog dog : arr) {
    System.out.println(dog);

  }
}

2.4 可变参数
a.什么是可变参数：是指方法参数的个数可以任意[JDK 1.5]
b.可变参数的格式：
数据类型 … 变量名

1
public static int getSum(int … a){}
可变参数的本质其实就是一个数组；
注意事项：
a.一个方法中最多只能有一个可变参数
b.一个方法中如果既有正常参数，又有可变参数，那么可变参数必须写在最后面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void main(String[] args) {
  System.out.println(getSum());
  System.out.println(getSum(1));
  System.out.println(getSum(1, 2));
  System.out.println(getSum(1, 2, 3));
  System.out.println(getSum(1, 2, 3, 4));
  System.out.println(getSum(1, 2, 3, 4, 5));
}

public static int getSum(int... a) {
  System.out.println("length: "+a.length);
  int sum = 0;
  for (int i : a) {
    sum +=i;
  }
  return sum;
}

2.5 可变参数的应用场景
Arrays工具类中有一个静态方法:
•public static List asList<T…a>:返回由指定数组支持的固定大小的列表
•返回的集合不能做 增 删 操作，可以做修改操作

List接口中有一个静态方法:
•public static List of(E…elements):返回包含任意数量元素的不可变列表
•返回的集合不能做 增 删 该 操作

Set接口中有一个静态方法:
•public static Set of(E…elements):返回一个包含任意数量元素的不可变集合
•在给元素时，不能给重复的元素

例：

1
2
3
4
5
6
7
8

public static void main(String[] args) {
  ArrayList<String > arr= new ArrayList<String>();
  //Collections工具类又有一个方法，叫做addAll
  Collections.addAll(arr,"a","b","c","d","e");

  System.out.println(arr);
}

一次性向集合中添加多个元素

三.Set接口
3.1 Set接口的特点
a.Set接口也是继承Collection接口
b.Set接口的特点：
无序的（指存取顺序不保证一致）
无索引的(使用不能使用普通for循环遍历)
元素唯一的

但是实际上，严格来说，无序特点是不对的(实现类LinkedHashSet是有序的)
3.2 Set接口的常用方法以及常用实现类
a.Set接口中的方法(7个collection+1个迭代器)
b.Set方法的特有方法：无

c.Set接口的实现类:
HashSet
LinkedHashSet
TreeSet
3.3 HashSet的数据结构以及使用
a.HashSet也没有特有方法
b.HashSet底层采用的是哈希表结构(数组结构+链表结构+红黑树结构)
•对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素 顺序一致
•没有带索引的方法，索引不能使用普通for循环遍历
•Set集合，所以是不包含重复元素的集合
c.HashSet的使用

1
2
3
4
5
6
7
8

public static void main(String[] args) {
  HashSet<String> set = new HashSet<String>();
  Collections.addAll(set, "php","Java","C#");
  Collections.addAll(set, "Java","C#","Delphi","C","CPP","Python");

  System.out.println(set);
}

3.4 LinkedHashSet的数据结构以及使用
a.LinkedHashSet也没有特有方法
b.LinkedHashSet底层采用的是（链表结构+哈希表结构）
•由链表保证元素有序，也就是说元素的存储和取出顺序是一样的
•由哈希表保证元素唯一，也就是说没有重复的元素

c.LinkedHashSet的使用

1
2
3
4
5
6
7
public static void main(String[] args) {
  LinkedHashSet LHS = new LinkedHashSet<String>();
  Collections.addAll(LHS, "php", "Java", "C#");
  Collections.addAll(LHS, "Java", "C#", "Delphi", "C", "CPP", "Python");

  System.out.println(LHS);
}

3.5 TreeSet的数据结构以及使用
a.TreeSet特点
无序的（无序是存取顺序不保证一致，但是它会以自然顺序输出）
TreeSet是无序的，但是它是无序中的一种特殊存在，有自然顺序！
TreeSet(Comparator comparator)：根据指定的比较器进行排序
无索引，所以不能用普通for循环
元素唯一，因为是Set集合
b.TreeSet特有方法:无
c.TreeSet底层采用的是红黑树结构
d.TreeSet的使用

1
2
3
4
5
6
7
8
9
10
TreeSet<Integer> tree = new TreeSet<Integer>();
//添加元素，没有带索引的方法，证明无索引
//tree.add()
Collections.addAll(tree, 1, 3, 5, 2, 4, 6);
System.out.println(tree);
//[1, 2, 3, 4, 5, 6]证明自然顺序

tree.add(4);
System.out.println(tree);
//[1, 2, 3, 4, 5, 6] 证明元素唯一性

扩展：
如果TreeSet保存的是数值类型，那么按照数值的大小升序
如果TreeSet保存是Character类型，那么按照字母的码值排序
如果TreeSet保存的是String类型，那么按照字母首字母排序，若一样，次字母排序，依次类推

e.TreeSet也可以使用比较器自定义排列顺序
TreeSet有一个带有比较器的构造方法

1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) {
  TreeSet<Integer> tree = new TreeSet<Integer>(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
      return o2-o1;
    }
  });
  Collections.addAll(tree, 1, 3, 5, 2, 4, 6);
  System.out.println(tree);
}

3.6 哈希表结构的的介绍
•对象的哈希值(对象的”数字指纹”，是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值)
a.对象的哈希值，相对于对象的“指纹”，只是这个指纹是一个数字
b.我们如何获取对象的哈希值：调用对象的hashCode()方法即可

1
2
3
4
5
public static void main(String[] args) {
Student s1 = new Student(1, “a”);
int hashCode = s1.hashCode();//返回哈希值
System.out.println(hashCode);
}
c.其实Java中所谓的地址值是假的，它是Hash值的16进制表示
源码

1
2
3
public String toString() {
  return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

d.Java中有真正的地址值，但是当打印时，会自动调用toString方法，将hash值输出
Dog d = new Dog();//d就是真正的地址值
System.out.println(d);//打印时，会自动调toString方法，hex16操作输出

e.不同的两个对象，可能有相同的hashCode（hashCode是int类型，最多42亿，因此会相同）

结论：哈希表结构如何保证元素的唯一性
哈希表结构，如何判断两个元素是否重复：
a.哈希表结构，会先比较两个对象的哈希值
b.当哈希值一样，再调用equals比较两个对象
只有哈希值相同，并且equals结构为true，才判定这两个元素是重复的

哈希表结构=数组结构+链表结构+红黑树结构（JDK8）
数组结构默认长度16
I.向哈希值中添加元素时，元素的索引：元素.hashCode()%数组长度 =0-15
II.当某个链表长度超过阀值(8)时，这个链表就会变成红黑树

3.7 哈希表结构保存自定义类型练习
为了保证哈希表中元素的唯一性，如果元素是自定义类型，那么必须重写hashCode和equals方法

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
69
70
71
72
public class Dog {
  int age;
  String name;
  int legs_num;

  public Dog(){

  }

  public Dog(int age, String name, int legs_num) {
    this.age = age;
    this.name = name;
    this.legs_num = legs_num;
  }

  @Override
  public String toString() {
    return "Dog{" +
      "age=" + age +
      ", name='" + name + '\'' +
      ", legs_num=" + legs_num +
      '}';
  }
  //为了保证哈希表中元素的唯一性，要重写hasCode和equals方法

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }
    Dog dog = (Dog) o;
    return age == dog.age &&
      legs_num == dog.legs_num &&
      Objects.equals(name, dog.name);
  }

  @Override
  public int hashCode() {
    return Objects.hash(age, name, legs_num);
  }
}

public class TestHashSetDemo {
  public static void main(String[] args) {
    HashSet<Dog> dogHashSet = new HashSet<Dog>();
    dogHashSet.add(new Dog(1, "a", 4));
    dogHashSet.add(new Dog(2, "b", 4));
    dogHashSet.add(new Dog(3, "c", 4));
    dogHashSet.add(new Dog(1, "d", 4));

    //        for (Dog d : dogHashSet) {
    //            System.out.println(d);
    //        }
    //        System.out.println();
    //
    //        dogHashSet.add(new Dog(3, "c", 4));
    //        //哈希表判断两个元素重复or不重复的依据是哈希表和equals
    //        for (Dog d : dogHashSet) {
    //            System.out.println(d);
    //        }

    //为了保证元素的唯一性，要重写hashCode和equals，根据内容计算哈希值，equals也比较内容

    System.out.println();
    for (Dog d:dogHashSet
        ) {
      System.out.println(d);
    }
  }

3.8 HashSet的源码分析
a.构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class HashSet<E> extends AbstractSet<E>
  implements Set<E>, Cloneable, java.io.Serializable {
  //内部一个HashMap——HashSet内部实际上是用HashMap实现的 private transient HashMap<E,Object> map;
  // 用于做map的值
  private static final Object PRESENT = new Object();

  /**
     * 构造一个新的HashSet，
     * 内部实际上是构造了一个HashMap
     */
  public HashSet() {
    map = new HashMap<>();
  }
}

b.HashMap的add方法

1
2
3
4
5
6
7
public class HashSet { //......
  public boolean add(E e) {
    return map.put(e, PRESENT) == null;//内部实际上添加到map中，键:要添加的对象，值:Object
    对象
  }
  //......
}

c.HashMap的put方法
HashMap保存键时，是以键的哈希值为依据确定键的保存位置
添加成功之后，size++，将元素的个数增加1

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
public class HashMap { //......
  public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
  }

  //......
  static final int hash(Object key) {//根据参数，产生一个哈希值
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
  }

  //......
  final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                 boolean evict) {

    Node<K, V>[] tab; //临时变量，存储"哈希表"——由此可见，哈希表是一个Node[]数组 
    Node<K,V> p;//临时变量，用于存储从"哈希表"中获取的Node
    int n, i;//n存储哈希表长度;i存储哈希表索引
    if ((tab = table) == null || (n = tab.length) == 0)//判断当前是否还没有生成哈希表
      n = (tab = resize()).length;//resize()方法用于生成一个哈希表，默认长度:16，赋给n
    if ((p = tab[i = (n - 1) & hash]) == null)//(n-1)&hash等效于hash % n，转换为数组索 
      tab[i] = newNode(hash, key, value, null);//此位置没有元素，直接存储
    else{//否则此位置已经有元素了 
      Node<K,V> e; K k;
      if (p.hash == hash &&
          ((k = p.key) == key || (key != null && key.equals(k))))//判断哈希值和
        e = p;//将哈希表中的元素存储为e
      else if (p instanceof TreeNode)//判断是否为"树"结构
        e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
      else {//排除以上两种情况，将其存为新的Node节点
        for (int binCount = 0; ; ++binCount) {//遍历链表 
          if ((e = p.next) == null) {//找到最后一个节点
            p.next = newNode(hash, key, value, null);//产生一个新节点，赋值到链
            if (binCount >= TREEIFY_THRESHOLD - 1) //判断链表长度是否大于了8 
              treeifyBin(tab, hash);//树形化
            break;
          }
          if (e.hash == hash &&
              ((k = e.key) == key || (key != null && key.equals(k))))//跟当前
            变量的元素比较，如果hashCode相同，equals也相同 break;//结束循环
          p = e;//将p设为当前遍历的Node节点 }
        }
        if (e != null) { // 如果存在此键
        }
      }

总结：

image

Collection
{
Iterator it = cc.iterator();
public boolean add(E e);添加元素，返回值表示是否添加成功。
public boolean remove(E e);删除元素，返回值表示是否删除成功。
无修改方法。
无查询方法。
public boolean contains(Object obj);判断集合中是否包含某个元素。
public void clear();清空集合（把集合中的元素全部删除，不是把集合置为Null）
public boolean isEmpty();判断集合是否为空（指集合中没有元素，而非集合是否为Null）
public int size();返回集合中元素的个数
public Object[] toArray();将集合转成数组
}
List接口：
特点：有序，有索引，元素可重复
特有方法：
add(int index,E e);
remove(int index,E e);
set(int index,E e);
get(int index,E e);

ArrayList：
底层是数组结构
特有方法：无
特点：有序，有索引，元素可重复

LinkedList
底层是链表结构
特有方法：
public void addFirst(E e);//添加元素到集合首
public void addLast(E e);//添加元素到集合尾
public E getFirst(E e);//获取集合的首元素
public E getLast(E e);//获取集合的尾元素
public E removeFirst(E e);//删除集合的首元素
public E removeLast(E e);//删除集合的尾元素
public void pop(E e);//删除集合中的首元素，底层就是removeFirst
public void push(E e);//添加集合中的首元素，底层就是addFirst
特点：有序，有索引，元素可重复

Set接口：
特点：无序（LinkedHashSet除外），无索引，元素唯一
特有方法：无
特点：无索引，元素唯一

HashSet
底层是哈希表结构(数组结构+链表结构+红黑树结构)
特有方法：无
特点：无序，无索引，元素唯一

LinkedHashSet
底层是（链表结构+哈希表结构）
特有方法：无
特点：有序，无索引，元素唯一

TreeSet
底层是红黑树结构
特有方法：无
特点：无序的（无序是存取顺序不保证一致，但是它会以自然顺序输出），无索引，元素唯一

使用哈希表保存自定义类型时，为了保证元素的唯一性，要重写自定义类型中的hashCode方法和equals方法

发表于 更新于

集合体系结构：
image

一.Collection集合（所有集合的根接口）
是单列集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
JDK不提供此接口的任何直接实现，它提供了更具体的子接口(如Set和List)实现
创建Collection集合的对象
•多态的方式
•具体的实现类ArrayList

1.集合的介绍&集合和数组的区别
a.什么是集合
集合就是Java用来保存数据的容器。
b.学过的容器
数组，ArrayList
数组定义: 数据类型[] 变量名 = new 数据类型[数组的长度]
集合定义: ArrayList<数据类型> 变量名 = new ArrayList<数据类型>();
c.数组和集合区别在哪里
I.数组的长度固定，集合的长度可变
II.数组中的元素类型可以是基本类型，也可以是引用类型。
集合中的元素类型必须只能是引用类型，如果想保存基本类型，要写该基本类型对应的写包装类。
例如：
ArrayList arr = new ArrayList();

2.集合框架的继承体系

List接口特点：
有序，有索引，元素可以重复

Set接口特点：
无序，无索引，元素不可以重复

image

3.Collection中的通用方法
增：增加
public boolean add(E e);添加元素，返回值表示是否添加成功。
删：删除
public boolean remove(E e);删除元素，返回值表示是否删除成功。
改：修改
无修改方法。
查：查询
无查询方法。
其他方法：
public boolean contains(Object obj);判断集合中是否包含某个元素。
public void clear();清空集合（把集合中的元素全部删除，不是把集合置为Null）
public boolean isEmpty();判断集合是否为空（指集合中没有元素，而非集合是否为Null）
public int size();返回集合中元素的个数
public Object[] toArray();将集合转成数组

方法名 说明
boolean add(E e) 添加元素
boolean remove(Object o) 从集合中移除指定元素
void clear() 清空集合中的元素
boolean contains(Object o) 判断集合中是否存在指定的元素
boolean isEmpty() 判断集合是否为空
int size() 集合的长度，也就是集合中的元素个数
public Object[] toArray(); 将集合转成数组
二.Iterator迭代器（遍历集合）
1.集合迭代器的介绍与使用
a.迭代器（iterator）
用于遍历集合的对象（集合有无索引，均可使用迭代器来遍历，迭代器遍历集合时不需要索引）
•Iterator iterator():返回此集合中元素的迭代器，通过集合的iterator()方法得到
•迭代器是通过集合的iterator()方法得到的，所以说他是依赖于集合而存在的

b.迭代器的使用
I.获取要遍历集合的迭代器对象
II.调用迭代器对象.hasNext();boolean类型
III.调用迭代器对象的.next();方法
1
2
3
4
5
6
7
8
9
10
Iterator it = cc.iterator();
// boolean b = a.hasNext();
// if (b) {
// String next = a.next();
// System.out.println(next);
// }
while(it.hasNext()){
String ss = it.next();
System.out.println(ss);
}
•迭代器的注意事项（2个异常）
a.NoSuchElementException
出现原因：迭代器的hasNext返回false，再调用next方法，就会返回此异常
b.ConcurrentModificationException
出现原因：Java的迭代器规定，使用迭代器过程中，不能向集合中增删元素（不能影响集合的长度），否则就会抛出并发修改异常。

结论：
a.使用迭代器时，必须先判断，且判断结果为true，才能调用.next()方法
b.使用迭代器时，应该尽量只做遍历（绝对不允许直接向集合中增删元素），即使用单纯遍历功能

2.迭代器的原理
迭代器的底层使用指针原理，迭代器输出的是内存地址，在地址块中寻找下一个，超出后提出越界，即返回NoSuchElementException错误。同理，地址不可变，使用增删会提示ConcurrentModificationException错误

3.增强for循环
a.什么是增强for循环
实际上是一种简便格式（语法糖），简化数组和Collection集合的遍历，实际上是迭代器的简便格式
b.增强for循环的用法
for(数据类型 变量名:集合/数组){}
c.增强for循环本质使用的就是迭代器
证明：
a.源码
b.如果在使用增强for的过程中向集合添加或删除元素，和迭代器一样会抛出ConcurrentModificationException异常

注意：和使用迭代器一样，增强for就是用于单纯的遍历集合，不要在遍历集合的过程中增删元素

三.泛型
1.什么是泛型
泛型是JDK1.5的新特性，提供了编译时类型安全检测机制，该机制允许在编译时见到到非法到类型
它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数
参数化类型：就是将类型由原来的具体到类型参数化，然后在使用/调用时传入具体到类型

比如：
在JDK1.5之前，创建集合:ArrayList arr = new ArrayList();集合中可以保存任意对象
在JDK1.5时，创建集合:ArrayList<具体的引用类型> arr = new new ArrayList<具体的引用类型>();
这种参数类型可以用在类、方法和接口中，分别被称为泛型类，泛型方法，泛型接口

什么是泛型：
是一种不确定的类型，程序员使用时再确定下来
泛型的格式：
,一个泛型，如Element。这里的类型可以看作形参
<K,V>,两个泛型，暂不确定类型。这里的类型可以看作形参
将来具体调用的适合给定的类型可以看作是实参，并且实参的类型只能是引用数据类型

2.泛型的好处
a.避免了强制转型的麻烦
b.避免了类型转换的异常，将运行时期的ClassCastException，转移到了编译时期的编译失败

总之：JDK1.5之后，Java强烈推荐使用泛型

3.泛型的定义和使用
泛型可以定义在类、方法、接口上

•泛型类
泛型可以定义在类上

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MyArrayList {
//就是把E当作某种类型使用
private E ee;

public E getEe() {
    return ee;
}

public void setEe(E ee) {
    this.ee = ee;
}

}

泛型类的使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class TestMyArrayList {
public static void main(String[] args) {
//使用泛型类，MyArrayList
MyArrayList arr = new MyArrayList();
// 此时arr中集合对象没有E了，所有E都变成了String
arr.setEe(“Java”);
String ee = arr.getEe();
System.out.println(ee);

// 使用泛型类，MyArrayList
MyArrayList arr1= new MyArrayList();
arr1.setEe(1);
System.out.println(arr1.getEe());
}
}
•泛型方法
泛型方法的定义：

1
2
3
4
5
public class Dog {
public void show(E num){
System.out.println(num);
}
}
泛型方法的使用：

1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) {
//create object
Dog dd = new Dog();
//use method
dd.show(“Java”);
dd.show(10);
//严格的方式
dd.show(“java”);
dd.show(10);
}
•泛型接口
泛型定义在某个接口上

1
2
3
4
public interface MyInterface {
public abstract void show(E ee) ;
public abstract void eat(E ee) ;
}
1
2
3
4
5
6
7
8
9
10
//a.定义一个实现类，实现该接口时，可以确定E的具体类型
public class MyClass implements MyInterface{
@Override
public void show(String ee) {
}

@Override
public void eat(String ee) {
}

}
1
2
3
4
5
6
7
8
9
10
11
public class MyClass2 implements MyInterface{
@Override
public void show(E ee) {
}

@Override
public void eat(E ee) {
}

}
//此时实现类就是一个泛型类，创建该类对象时，可以确定泛型的具体类型

丢弃泛型（不正规）,此时泛型被丢弃，所有泛型变为Object

1
2
3
4
5
6
7
8
9
10
11
public class MyClass3 implements MyInterface{
@Override
public void show(Object ee) {

}

@Override
public void eat(Object ee) {

}

}
总结：在开发中，很少自定义泛型类、方法、接口，大概率是使用已定义好的泛型类，自行更改类型即可

4.泛型通配符
什么是泛型通配符：
当集合中泛型不确定类型时，可以使用泛型通配符，表示何种泛型均可

•类型通配符: •List:表示元素类型未知的List,它的元素可以匹配任何的类型
•这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加进去

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String[] args) {
ArrayList arr1 = new ArrayList();
ArrayList arr2 = new ArrayList();
ArrayList arr3 = new ArrayList();

method(arr1);
method(arr2);
method(arr3);

}

public static void method(ArrayList<?> arr) {

}
5.泛型的上下限
<?>什么泛型都是OK的

如果不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上线

,叫泛型的上限，表示该泛型必须是Animal本类或其子类(Dog,Cat); 可以理解为”” .叫泛型的下限，表示该泛型必须是Student本类或其父类(Person，Object) 可以理解为”
=Student>”

范例：

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
public static void main(String[] args) {
Collection list1 = new ArrayList();
Collection list2 = new ArrayList();
Collection list3 = new ArrayList();
Collection list4 = new ArrayList();
//Number是8种数值类型的父类
//SuperClass:Object—subclass（String,Number)—subclass(Integer,Number)

    getElement1(list1);

// getElement1(list2);String和Number不是super-sub关系，不行
getElement1(list3);
// getElement1(list4);Object最大，不行

// getElement2(list1);Integer小于Number，不行
// getElement2(list2);String和Number不是Super-sub关系，不行
getElement2(list3);
getElement2(list4);
}

public static void getElement1(Collection<? extends Number> collection ) {

}

public static void getElement2(Collection<? super Number> collection ) {

}

}
四.数据结构
1.什么是数据结构
数据结构是计算机存储、组织数据的方式(容器保存数据的方式)。是指相互之间存在一种或多种特定关系的数据元素的集合

2.常见的4+1种数据结构
掌握前4种数据结构
•栈结构
可以看成只有一端开口的容器
入栈/压栈->[栈顶U栈底]->出栈/弹栈
入栈顺序：1 2 3
出栈顺序：3 2 1

特点：先进后出

•队列结构
两端均有开口的容器
入队->[队尾——队头]->出队

只能从队尾进

入队顺序：1 2 3 4
出队顺序：1 2 3 4

特点：先进先出FIFO(First In First Out)

•数组结构
数组结构是连续的一块区域，每个数组都有自己的索引

获取/修改元素：根据索引找到/修改元素即可

添加元素经过：
a.创建新数组
b.复制老数组数据
c.添加新的数据
d.销毁老的数据

删除元素经过：
a.创建新数组
b.复制老数组数据
c.删除指定的数据
d.销毁老的数据

特点：增删慢，查改快

•链表结构
在链表结构中，每一个元素称为node(节点/结点),每个node至少有两部分内容

单向链表结构
双向链表结构

数据域｜指针域（指向下一个node）
（指向上一个node）指针域｜数据域｜指针域 （指向下一个node）

image

获取/修改元素:从第一个元素开始往后查找(比数组结构慢)
增加/删除元素:在指针域直接添加/删除新node

特点：链表结构在内存中是可以分散的，增删快，查改慢

了解另一种数据结构
•树结构
树具有的特点:

每一个节点有零个或者多个子节点
没有父节点的节点称之为根节点，一个树最多有一个根节点。 3. 每一个非根节点有且只有一个父节点

image

名词 含义
结点 指树中的一个元素
结点的度 节点拥有的子树的个数，二叉树的度不大于2
叶子结点 度为0的节点，也称之为终端结点
高度 叶子结点的高度为1，叶子结点的父节点高度为2，以此类推，根节点的高度最高
层 根节点在第一层，以此类推
父节点 若一个节点含有子节点，则这个节点称之为其子节点的父节点
子结点 子节点是父节点的下一层节点
兄弟结点 拥有共同父节点的节点互称为兄弟节点
二叉树：如果树中的每个节点的子节点的个数不超过2，那么该树就是一个二叉树。

image

二叉查找树：
二叉查找树的特点:

左子树上所有的节点的值均小于等于他的根节点的值
右子树上所有的节点值均大于或者等于他的根节点的值
每一个子节点最多有两个子树

image

遍历获取元素的时候可以按照”左中右”的顺序进行遍历;
注意:二叉查找树存在的问题:会出现”瘸子”的现象，影响查询效率

image

二叉平衡树：
概述
为了避免出现”瘸子”的现象，减少树的高度，提高我们的搜素效率，又存在一种树的结构:”平衡二叉树” 规则:它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树

image

如图所示，上图是一棵平衡二叉树，根节点10，左右两子树的高度差是1，而下图，虽然根节点左右两子树高度 差是0，但是右子树15的左右子树高度差为2，不符合定义，
所以右图不是一棵平衡二叉树。

image

红黑树：

每一个节点或是红色的，或者是黑色的。
根节点必须是黑色
每个叶节点(Nil)是黑色的;(如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil，这些
Nil视为叶节点)
如果某一个节点是红色，那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)
对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点;
红黑树的特点：
查询效率非常恐怖，增删速度非常慢

总结：
1.Collection集合根接口
I.集合继承体系
II.Collection中定义的通用方法
III.明白集合和数组的区别
2.迭代器
I.迭代器使用的三个步骤：获取迭代器，判断有没有下一个，取出下一个元素
II.增强for循环使用（底层使用就是迭代器）
III.迭代器和增强for使用过程，不能增删元素

3.泛型
I.泛型怎么写
II.泛型类、接口、方法怎么定义和使用
III.泛型通配符以及上下限
<?>代表任意泛型即可
<? extends X >上限
<? super Xxx>下限

4.数据结构
栈结构：先进后出
队列结构：先进先出
数组结构：增删慢，查改快
链表结构：增删快，查询慢

红黑树：查询效率非常高，增删速度非常慢

发表于 更新于

一.BigInteger类
BigInteger类
java.math.BigInteger类，用于大整数计算(理论上整数位数是不受限制的)

BigInteger的构造方法

1
public BigInteger(String num);//创建一个大整数
BigInteger的成员方法
BigInteger不能直接使用+-*/进行计算，而是要通过方法进行计算

1
2
3
4
public BigInteger add(BigInteger value);//求和
public BigInteger subtract(BigInteger value);//求差
public BigInteger multiply(BigInteger value);//求积
public BigInteger divide(BigInteger value);//求商

二.BigDecimal类
使用基本类型会出现精度差
计算机计算小数时，总是存在不精确的情况

BigDecimal类的介绍
提供了算数、缩放操作、舍入、比较、散列和格式转换的操作。提供了更加精确的数据计算方式。

BigDecimal的构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
public BigDecimal(double d);
public BigDecimal(String d);[推荐]

//BigDecimal的成员方法
public BigDecimal add(BigDecimal value);//求和
public BigDecimal subtract(BigDecimal value);//求差
public BigDecimal multiply(BigDecimal value);//求积
public BigDecimal divide(BigDecimal value);//求商（能除尽）
//注意：如果除不尽，会抛出异常java.lang.ArithmeticException
//此时，可以使用另一个divide方法的重载
public BigDecimal divide(BigDecimal value,int 保留位数,oundingMode.roundingMode);
//范例
BigDecimal divide = bd1.divide(new BigDecimal("0.3"), 5, RoundingMode.HALF_UP);

三.Array类
3.1 Arrays类的介绍
Arrarys是专门操作数组的工具类（方法都是静态的）

工具类的设计思想：
•构造方法用private修饰
•成员用public static修饰

3.2 Array类的常用方法

方法名 说明
public static void sort(int[] a); 对数组进行从小到大的排序
public static String toString(int[] a); 将一个数组的元素拼成一个大的字符串
extend：
sort方法对于数值类型的数组排序时，按照数值的从小到大进行排序。
sort方法对于char类型的数组排序时，按照字符码值的从小到大进行排序。
sort方法对于String类型的数组排序时，首先比较首字母的码值，如果相等，再比较次字母的码值，依次类推，从小到大进行排序。

四.包装类
4.1 包装类的作用
Java提供了两个类型，基本类型和引用类型，基本类型效率高，但是引用类型可操作性高，把基本类型包装成引用类型，就是包装类。
包装类就是基本类型对应的引用类型，全称叫基本数据类型的包装类（简称包装类）

基本类型包装类概述：将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
常用操作之一：用于基本数据类型与字符串之间的转换

基本类型 引用类型
byte Byte
short Short
*char Character
*int Integer
long Long
float Float
double Double
boolean Boolean
4.2 Integer包装类介绍
Integer是int基本类型的包装类

4.3 Integer类的构造方法和静态方法
构造方法：

1
2
public Integer(int value);//过时
public Integer(String value);//过时
静态方法：

方法名 说明
public static Integer valueof(int value); 返回表示指定的int值类型的Integer实例
public static Integer valueof(String value); 返回一个保存指定值的Integer对象String
范例：

1
2
3
4
5
6
7
8
9
10
11
12
Integer i1 = new Integer(10);
System.out.println(i1);

Integer i2 = new Integer("11");
System.out.println(i2);

Integer i3 = Integer.valueOf(12);
System.out.println(i3);

Integer i4 = Integer.valueOf("13");
System.out.println(i4);

4.4.1 拆箱和装箱
基本类型和对应的包装类是可以相互转换的。

装箱：把基本类型———转换成————>对应包装类
拆箱：包装类———转换成————>对应的基本类型

例如：

1
2
3
4
5
6
//装箱操作
Integer i1 = new Integer(10);
Integer i3 = Integer.valueOf(12);

//拆箱操作
int value = i1.intValue();

4.4.2 自动拆箱和装箱*[JDK 5中引入该操作]

1
2
3
Integer i =4；//底层已经调用Integer.valueOf()方法自动帮助进行装箱操作

int value  = i;//底层调用i.intValue()自动帮助我们进行拆箱操作

注意:在使用保证类类型时，如果做操作，最好先判断是否为null
推荐：只要是对象，在使用前将必须进行不为null的判断

题：
Integer a = 10;//装一次
a++;//拆一次 装一次
自动装箱2次
自动拆箱1次

4.5 基本类型与字符串之间的转换

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
•基本类型转换成String

  int num = 10；

  a.直接加一个" "
  String s = num + " ";

b.通过String的静态方法valueOf
  String s = String.valueof(num);
•String转换成基本类型
  String num = "100";
方式一：
  a.
  先使用Integer的构造方法
  Integer i = new Integer(num);
b.
  接着拆箱调用intValue方法拆箱
  int number = i.intValue();
或不调用intValue方法自动拆箱接口
  int number = i
  方式二：
  直接调用包装类的parseXxx(String s)解析字符串方法
  int number = Integer.parseInt(num);
•字符串无法解析成基本类型失败时的异常
  Exception in thread "main" java.lang.NumberFormatException

五.String类常用方法
String的构造方法：
直接赋值：
String s = “java”;
构造方法：
String s = new String(“java’);

char[] chs = {“j”,”a”,”v”,”a”};
String s = new String(chs);

byte[] bs = {97,98,99,100};
String s = new String(bs);//最终结果是ASCII码对应的字符

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
69
70
71
72
73
74
75
76
77
78
79
80
81
public static void main(String[] args) {
    String s = "Hello,World";
    //1.concat 拼接
    String s1 = s.concat("+Java");
    System.out.println(s1);//Hello,World+Java

    //contains 判断是否包含某个小字符串
    boolean b1 = s.contains("o");
    boolean b2 = s.contains("world");
    System.out.println(b1);//true
    System.out.println(b2);//false

    //endswith 是否以该字符结尾
    boolean b3 = s.endsWith("ld");
    boolean b4 = s.endsWith("lo");
    System.out.println(b3);//true
    System.out.println(b4);//false

    //startwith 是否以该字符开头
    boolean b5 = s.startsWith("He");
    boolean b6 = s.startsWith("Wo");
    System.out.println(b5);//true
    System.out.println(b6);//false


    //indexOf查找目标字符串在当前字符串第一次出现的索引
    int index1 = s.indexOf("o");
    System.out.println(index1);//4
    int php = s.indexOf("php");
    System.out.println(php);// -1

    //lastdexOf查找目标字符串在当前字符串最后一次出现的索引
    int index2 = s.lastIndexOf("o");
    System.out.println(index2);//7
    int delphi = s.lastIndexOf("delphi");
    System.out.println(delphi);// -1

    //replace 将当前字符串中的目标字符串替换为另外一个字符串
    String replace = s.replace("Hello", "Halo");
    System.out.println(replace);//Halo,World
    String replace1 = s.replace("php", "Halo");
    System.out.println(replace1);//Hello,World

    //substring 指定
    String subs = s.substring(2);
    System.out.println(subs);//llo,World
    String subs1 = s.substring(2,5);
    System.out.println(subs1);//llo,截取到5之前，不包含5

    //toCharArry 将字符转换成char Array
    char[] chs = s.toCharArray();
    System.out.println(chs);//Hello,World
    System.out.println(Arrays.toString(chs));//[H, e, l, l, o, ,, W, o, r, l, d]

    //toLowerArry 转成小写
    String s2 = s.toLowerCase();
    System.out.println(s2);//hello,world

    //toUpperArry 转成大写
    String s3 = s.toUpperCase();
    System.out.println(s3);//HELLO,WORLD


    String ss = "   Hello     ,World   ";
    //trim 去除字符串两端的空格
    String trim = ss.trim();
    System.out.println(trim);//Hello     ,World


    String sss = "a,b,c,d,e,f";
    //split 切割字符串
    String[] split = sss.split(",",7);
    String s4 = Arrays.toString(split);
    System.out.println(s4);//[a, b, c, d, e, f]
    System.out.println(split[0]);//a
    System.out.println(split[1]);//b
    System.out.println(split[2]);//c
    System.out.println(split[3]);//d
    System.out.println(split[4]);//e
    System.out.println(split[5]);//f
}

六.引用类型使用小结
6.1 类名作为方法参数和返回值
主要是（类，抽象类，接口，以及多态）复习

基本类型：

1
2
3
4
5
6
public void show(int a){

}
public int method(){

}

普通类,也可以作为方法的参数和返回

1
2
3
4
5
6
public void show(Dog g){

}
public Dog method{

}

抽象类，也可以作为方法的参数和返回

1
2
3
4
5
6
public void show(Animal a){
  //Animal a = 任意一个子类对象
}
public Animal method{

}

接口，也可以作为方法的参数和返回

1
2
3
4
5
6
public void show(Flyable a){
  //Flyable f = 该接口的任意一个实现类对象
}
public Flyable method(){

}

总结：
a.当基本类型作为方法的参数和返回值时，调用方法和返回数据时，返回该基本类型的值即可
b.当引用类型作为方法的参数和返回值时，调用方法和返回数据时，返回该引用类型的对象/子类对象/实现类对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String[] args) {
  killPerson(new Person(18,"a"));
  Person pp = birthPerson();
  System.out.println(pp);
}
public static void killPerson(Person p){
  System.out.println("ppp");
  System.out.println(p);

}

public static Person birthPerson() {
  return new Person(3,"bbb");

}

总结：当方法的参数或者返回值是普通类时，我们要传入或返回对象的是该类的对象

6.2 抽象类作为方法参数和返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String[] args) {
  show(new Dog());
  show(new Cat());
  Animal an = BirthAnimal();
  an.eat();
  an.bark();
}
public static void show(Animal an){
  an.eat();
  an.bark();
}
public static Animal BirthAnimal(){
  //        return new Dog();
  return new Cat();
}

总结：当方法的参数或者返回值是抽象类时，我们要传入或返回对象的是该类的子类对象

6.3 接口作为方法参数和返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args) {
  showFly(new Bird());
  showFly(new Plane());
  Flyable fa = getfly();
  fa.fly();
}
//定义方法，使用Flyable接口
public static void showFly(Flyable fa){
  fa.fly();
}
public static Flyable getfly(){
  //        return new Plane();
  return new Bird();
}

总结：当方法的参数或者返回值是接口时，我们要传入或返回对象的是该类的实现类对象

6.4 类名作为成员变量的，其实引用类型也可以作为类的成员变量

1
2
3
4
5
6
7
public class Student{
  int age;
  String name;
  Dog dog;
  Animal an;
  Flyable fa;
}

总结：当普通类作为成员变量，给该成员变量赋值时，赋值普通类的对象
6.5 抽象类作为成员变量

1
2
3
4
5
6
7
8
9
10
11
12
public class Student {
  int age;
  String name;
  Animal an;
}
public static void main(String[] args) {
  Student ss =new Student();
  ss.age = 1;
  ss.name = "s";
  ss.an = new Dog();

}

总结：当抽象类作为成员变量时，当给该成员变量赋值，赋值给该成员类的子类对象

6.6接口作为成员变量

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
public class Student {
  private int age;
  private String name;

  public int getAge() {
    return age;
  }

  public void setAge(int age) {
    this.age = age;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public Flyable getFa() {
    return fa;
  }

  public void setFa(Flyable fa) {
    this.fa = fa;
  }

  private Flyable fa;
}

public class TestDemo11 {
  public static void main(String[] args) {
    Student ss = new Student();
    ss.setAge(1);
    ss.setName("a");
    ss.setFa(new Bird());

  }
}

总结：当接口作为成员变量时，当给该成员变量赋值，赋值给该成员类的实现类对象

总结
1.BigInteger
2.BigDecimal
add subtract multiply divide

3.Arrays工具类*
public static void sort(int[] arr);默认对数组进行升序排序
public static String toString(int[] arr);将数组的所有元素拼在一起成一个大字符串返回

4.包装类*
a.八种基本类型对应的引用类型
b.装箱和拆箱（JDK5之后，自动拆装箱）
Integer i = 10;
int j =1;

5.String **
构造方法和常用的13个成员方法

6.引用类型的使用总结
引用类型作为方法的参数和返回值
引用类型作为成员变量

如果引用类型是普通类，那么用到该普通类的普通类对象
如果引用类型是抽象类，那么用到该抽象类的子类对象
如果引用类型是接口，那么用到该接口的实现类对象

发表于 更新于

一. Object类
1.1 Object介绍
Object类是所有类的父类，所有对象（包括数组）都具有该类中的11种方法。

构造方法：
public Object();

为什么之前说子类的构造方法默认访问的是父类的无参构造方法，因为它们的顶级父类只有无参构造方法

如果一个类我们没有指定其父类，那么默认继承Object

1
2
public class Dog /*extends Object*/{
}

1.2 toString方法
作用：返回该对象的字符串表示（调用的对象）
默认字符串表示的形式：
包名.类名@地址值
com.test.Demo01.Dog@61bbe9ba

在实际开发中，我们通常会重写toString方法，将本类返回的地址值改回返回对象的内容

1
2
3
4
5
6
7
8
9
10
11
12
13
@Override
public String toString() {
  return "Dog{" +
    "age=" + age +
    ", name='" + name + '\'' +
    '}';
}

public static void main(String[] args) {
  Dog dd = new Dog(10,"a");
  String  ss = dd.toString();
  System.out.println(ss);
}

Dog{age=10, name=’a’}
Dog{age=20, name=’b’}

注意：重写toString方法之后，当调用对象的toString方法时，返回的不再是地址值，而是具体的属性值。
实际上，不需要手动调用toString方法，可以简写为：

1
2
Dog d = new Dog();
System.out.println(d);

打印变量d，会自动调用d.toString()，其实就是打印toString方法值的返回值

总结：

1
2
3
System.out.println(ss2.toString());
//等同于
System.out.println(ss2);

1.3 equals方法
作用：判断其他对象是否是此对象“相等”。
默认比较的是两个对象的地址值
equals源码：

1
2
3
public boolean equals(Object obj) {
    return (this == obj);
}

在实际开发中， 也会重写equals方法，将本来的比较地址值改为比较内容（属性值）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Override
public boolean equals(Object o) {
  //合法性判断
  /*
    this --- age1
    o    --- age2
    */
  //比较地址是否相同
  if (this == o) return true;
  //判断参数是否为null
  //getClass判断是否来自同一个类(对比字节码Class文件)
  if (o == null || getClass() != o.getClass()) return false;
  //向下转型
  Cat cat = (Cat) o;
  //判断时，必须当前对象的age和比较对象的age相同，切当前name和比较对象name相同，才返回true
  return age == cat.age &&
    Objects.equals(name, cat.name);
}

方法名 说明
public String toString(); 返回对象的字符串形式表示。建议所有子类重写该方法，IDE自动生成
public boolean equals(Object obj); 比较对象是否相等，默认比较地址，重写可以比较内容，IDE自动生成
1.4 native本地方法
有native修饰的方法，称为本地方法，不是用Java写的，是使用底层C/C++写的。

1
public native int hashCode()

1.5 扩展（equals和==的区别）
对于基本类型：
== 比较的是数值
没有equals方法
对于引用类型：
== 比较的是地址值
equals默认情况下比较的是地址值，@override后，就按照重写的比较规则比较（一般比较属性值）

1.6 Objects类
Objects类，称之为工具类（内部所有的方法都是静态的）
在Objects中有一个方法：
public static boolean equals(Object a, Object b);
用于判断两个对象是否“相等”，并避免类空指针异常，该方法源码如下：

1
2
3
public static boolean equals(Object a, Object b){
  return( a == b ) || ( a != null && a.equals(b));
}

二. Date 类
2.1 Date类的介绍
包：java.util.Date
作用：代表某一个时间点，可以精确到毫秒

2.2 Date类的构造方法

方法名 说明
public Date(); 创建一个Date对象，并初始化，代表当前的系统时间，精确到毫秒。
public Date(long date); 创建一个Date对象，代表距离国际基准设计millis后的时间。
2.3 Date类的常用方法

方法名 说明
public void getTime(); 获取当前Date对象距离基准时间(1910-1-1 00:00:00)的毫秒值。
public void setTime(long date); 设置时间，修改当前Date对象距离基准时间的毫秒值
三. DateFormat类
3.1 DateFormat类的作用
让时间/日期和具体的文本直接来回转换

SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日前。

日前和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从’A’到’Z’以及从’a’到’z’引号的字母被解释为表示日期或时间字符串的组件的模式字母

格式化：将 Date对象 转成具体的 时间文本字符串
解析：将 时间字符串 转回 Date对象

3.2 DateFormat类的构造方法
DateFormat is an abstract class for date/time

DateFromat是抽象类，使用其子类（SimpleDateFormat）
public SimpleDateFormat(String pattern,
DateFormatSymbols formatSymbols);
这里的pattern表示我们想要的时间字符串格式/模式

方法名 说明
public SimpleDateFormat(); 构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern); 构造一个SimpleDateFormat使用给定的模式和默认的日期格式
Letter Date or Time Component Presentation Examples
G Era designator Text AD
y Year Year 1996; 96
Y Week year Year 2009; 09
M Month in year (context sensitive) Month July; Jul; 07
L Month in year (standalone form) Month July; Jul; 07
w Week in year Number 27
W Week in month Number 2
D Day in year Number 189
d Day in month Number 10
F Day of week in month Number 2
E Day name in week Text Tuesday; Tue
u Day number of week (1 = Monday, …, 7 = Sunday) Number 1
a Am/pm marker Text PM
H Hour in day (0-23) Number 0
k Hour in day (1-24) Number 24
K Hour in am/pm (0-11) Number 0
h Hour in am/pm (1-12) Number 12
m Minute in hour Number 30
s Second in minute Number 55
S Millisecond Number 978
z Time zone General time zone Pacific Standard Time; PST; GMT-08:00
Z Time zone RFC 822 time zone -0800
X Time zone ISO 8601 time zone -08; -0800; -08:00
主要：
y – 年
M – 月
d – 日
H – 时
m – 分
s – 秒

3.3 DateFormat类的成员方法

方法名 说明
public String format(Date date); 格式化方法，将日期格式化成日期/时间字符串
public Date parse(String date); 解析方法，从给定字符串的开始解析文本以及生成日期

1
2
3
4
5
6
7
8
public static void main(String[] args) throws ParseException {
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
  Date now = new Date();
  String nowStr = sdf.format(now);
  System.out.println(nowStr);
  Date date = sdf.parse("2020年04月07日 11:18:09");
  System.out.println(date);
}

四. Calendar类
4.1 Calendar的介绍和获取对象方式：
概述：
Calendar为某一时刻和一组日历字段直接的转换提供了一些方法，并为操作日历字段提供了一些方法

作用：表示某个时间点
获取对象的方式：
创建其子类GregorianCalendar类的对象（目前不使用）

使用Calendar的静态方法【推荐方式】：
Calendar c = Calendar.getInstance();创建一个子类对象，返回

注意：在Calendar类中，月份（0-11），代表我们的（1-12）

4.2 Calendar类中常见的方法

方法名 说明
public int get(int field); 返回给定日历字段的值
public abstract void add(int field,int amount); 根据日历的规则，将指定的时间量添加或减去给定的日历字段
public final void set(int year,int month,int date); 设置当前的日历年月日

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
public static void main(String[] args) {
  //获取一个Calendar对象
  Calendar c = Calendar.getInstance();//多态形式
  System.out.println(c);
  //获取Calendar对象中的某个数值
  int year = c.get(Calendar.YEAR);
  System.out.println("Year:"+year);

  int month = c.get(Calendar.MONTH );
  System.out.println("Month: "+month);

  int day = c.get(Calendar.DAY_OF_MONTH);
  System.out.println("Day: "+day);
}

public static void main(String[] args) {
  //获取一个Calendar对象
  Calendar c = Calendar.getInstance();
  System.out.println(c);
  //修改Calendar对象中某个成员的值
  c.set(Calendar.YEAR,3000);
  c.set(Calendar.MONTH,3);
  c.set(Calendar.DAY_OF_MONTH,20);
  print(c);
  //增加Calendar对象中某个成员的值
  c.add(Calendar.YEAR,20);
  c.add(Calendar.MONTH,3);
  c.add(Calendar.DAY_OF_MONTH,20);
  print(c);
}

注意：
a.Calender类中，month从0-11，我们是1-12
b.时间日期，也有大小之分，时间越靠后，我们认为其越大

五. Math类
5.1 Math类的介绍
Math中主要包含了一些数学运算相关的方法
Math类中这些方法都是静态的（通过类名就可以直接调用,Math当作一个工具类）

5.2 常用方法

1
2
3
4
5
6
7
8
9
10
public static double abs(double d);//求绝对值
public static double ceil(double d);//向上取整
public static double floor(double d);//向下取整
public static int round(float d);//四舍五入到整数

public static int max(int a,int b);//返回两个int值中的较大值
public static int min(int a,int b);//返回两个int值中的较小值
public static double pow(double a,double b);//求次幂,返回a的b次幂的值

public static double random();//返回值为double的正值，[0.0,1.0]

注意：
ceil只要有小数部分不是0，就向整数位进1
floor无论如何，小数部分不要，只要整数部分
Math.ceil(3.0);==> 3.0
Math.floor(3.0);==> 3.0

六. System
6.1 System类的介绍
The System class contains several useful class fields and methods. It cannot be instantiated.
System类中包含几个静态到变量和静态到方法，且该类不能被实例化（无法被创建对象）

方法名 说明
public static void exit(int status); 终止当前运行的Java虚拟机，非0表示异常终止
public static long currentTimeMillis(); 返回当前时间(以毫秒为单位)
System源码表示构造被私有化，故而无法创建对象
源码：

1
2
3
/** Don't let anyone instantiate this class */
private System() {
}

6.2 System类到常见用法

1
public static void exit(int status);
作用：退出Java虚拟机

1
public static long currentTimeMillis()
作用：获取当前系统毫秒值

1
2
3
4
5
6
7
8
9
10
long start_new = System.currentTimeMillis();

StringBuilder s1 = new StringBuilder();
for (int i = 0; i < 5000; i++) {
  s1.append(i);
}

long end_new = System.currentTimeMillis();

System.out.println("time:"+(end_new-start_new));

总结：
1.Object：所有类的父类
toString：默认返回的字符串表示，包名.类名@地址名
开发中一般会重写toString，返回对象的内容（command+n自动生成）
注意：实际上不需要手动调用toString方法，因为在使用对象时，编译器会自动调用toString()方法

equals默认比较的是两个对象的地址值，在开发中一般会@override，比较两个对象的内容（属性值）

2.Date & DateFormat

构造方法：
public Date();//当前系统时间
public Date(long millins);//距离基准时间millis毫秒后的时间

成员方法：
public long getTime();//获取当前Date对象距离基准时间的毫秒值
public long setTime(long millins);//设置当前Date对象距离基准时间的毫秒值

SimpleDateFormat<子类> extends DateFormat<抽象类>
构造方法：
public SimpleDateFormat(String 模式/格式);//“yyyy-MM-dd HH:mm:ss”

成员方法：
格式化：
public String format(Date date);
解析：
public Date parse(String time);

3.Calendar
获取对象：
Calendar c = Calendar.getinstance();//返回Calendar的子类对象
成员方法：
public void get(int field);
public void set(int field,int value);
public void add(int field,int value);

4.Math
Math类中方法都是静态的
public static double abs(double d);
public static double ceil(double d);
public static double floor(double d);
public static double rount(double d);
public static double pow(double d);

5.System
System类中方法都是静态的
public static void exit(0);//退出JVM
public static long currentTimeMills();//获取当前时间的毫秒值（用于计算某段代码的运行时间）

发表于 更新于

一. 多态
面向对象三大特征：封装，继承，多态
1.1 多态定义：
a.严格的定义：同一个动作，具有不同的表现形式
b.不严格定义：同一个对象，具有不同的形态

1.2 多态的前提
a.必须有继承关系，或者实现关系
b.必须有方法的重写
c.有父类引用指向子类对象
只有满足以上三个前提，才有多态

1.3 多态的体现
语言表达：父类类型的变量 指向了子类类型的变量（地址）
代码表达：

1
Parent P = new Sub();
范例：
1
Animal A = new Dog();(假设Dog已经继承了Animal，并重写了某个方法)
1.4 多态调用方法的特点
a.多态调用方法时，编译阶段看父类
b.多态调用方法时，运行阶段看子类
总结：多态调用方法的特点是编译看父，运行看子

多态成员访问特点:
•成员变量:编译看父，执行看父
•成员方法:编译看父，执行看子

为什么成员变量和成员方法访问不一样
•因为成员方法有重写，成员变量没有

1.5 多态的好处

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class TestDemo02 {
  public static void main(String[] args) {
    Dog dogname = new Dog();
    Feed_Animal(dogname);
    Cat catname = new Cat();
    Feed_Animal(catname);
  }

  public static void Feed_Animal(Animal an){
    System.out.println("Come to Eat");
    an.eat();

  }
}

总结：多态提供了代码的扩展性/灵活性
具体体现：定义方法时，使用父类类型作为参数，将来在使用时，使用具体的子类型参与操作

1.6 多态的弊端
多态调用特点：编译看父，运行看子
弊端：使用多态时，只能调用子父类都有的方法，不能调用子类独有的方法

1.7 多态弊端的解决方法-向下转型

1
2
3
4
5
6
7
8
//向上转型(把子类类型转换成父类类型)：
Animal an = new Dog();
dd.eat();
Dog dd = new Animal();

//向下转型（把父类类型转回子类类型）：
Dog dog = (Dog) dd;
dog.sleep(;)

1.8 转型可能出现的异常
ClassCastException 类型转换异常
当多态一个子类是A，向下转型是另一个子类B时，会出现转换异常。

1.9 instanceof 关键字介绍
可以判断一个对象，是否是我们指定类的对象

boolean b = 对象名 instanceof 

1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args) {
  Animal an = new Cat();
  an.eat();

  if(an instanceof Dog){
    Dog dd = (Dog)an;
    dd.Housekeeping();
  }
  if(an instanceof Cat){
    Cat cc = (Cat)an;
    cc.catchMouse();
  }

二. 内部类
2.1 什么是内部类
所谓的内部类就是在一个类A内部定义一个另外一个类B，此时类B内部类，类A外部类

按照内部类在类中定义的位置不同，可以分为如下两种形式
•在类的成员位置：成员内部类
•在类的局部位置：局部内部类

创建格式：
外部类名.内部类名 对象名 = 外部类对象.内部类对象；
范例：Outer.Inner oi = new Outer().new Inner();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Human {
  int age;
  String name;
  //    内部类
  //    成员内部类
  class Heart{
    int JumpCount;
    public void Jump(){
      System.out.println("Heart Jump");
    }
  }
  //    局部内部类
  public void Show(){
    class xxx{    }
  }
}

成员内部类有两个特点：
a.在成员内部类中可以无条件访问外部类的任何成员(包括私有)
b.外部类要访问内部类的成员，必须创建对象

在测试类中创建成员内部类对象写法：

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
public static void main(String[] args) {
  //创建外部类对象
  Human H1 = new Human();
  //Java 规定想要创建内部类的对象，必须先创建外部类的对象，然后通过外部类对象才能创建内部类对象
  Human.Heart HH1 = new Human().new Heart();
  //也可以这么写
  Human.Heart HH2 = H1.new Heart();
}

public class Outer{
  private int num = 10;
  private class Inner{
    public void show(){
      System.out.println(num)
    }
  }
  public void method(){
    Inner i = new Inner();
    i.show();
  }
}

public class OuterDemo{
  public static void main(String[] args) {
    Outer o = new Outer();
    o.method();
  }
}

局部内部类：
局部内部类是在方法中定义的类，所有外交无法直接使用，需要在方法内部创建对象并使用
该类可以直接访问外部类的成员，也可以访问方法内的局部变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Outer{
  private int num = 10;}
public void method(){
  int num2 = 20;
  class Inner{
    public void show(){
      System.out.println(num)
        System.out.println(num2)
    }
  }
  Inner i = new Inner();
  i.show();
}

public class OuterDemo{
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

2.3 内部类编译之后的字节码文件
内部类编译之后的字节码文件名：
外部类名$内部类名
范例：
Human$Heart.class

2.4 匿名内部类
•什么是匿名内部类
概念：局部内部类的简化形式，简化到不需要内部类的名字

•前提：存在一个类或接口，这里的类可以是具体类也可以是抽象类

•匿名内部类的作用
匿名内部类可以帮助我们快速的创建一个父类的子类对象或者一个接口的实现类对象

•本质：是一个继承了该类或者实现类该类接口的子类匿名对象

•格式：
new 类名或接口名(){
重写方法；
};

范例：

1
2
3
new Inter(){
  public void show(){}
}

•匿名内部类的使用特点1

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

public class TestDemo06 {
  public static void main(String[] args) {
    //使用匿名内部类
    Animal dd = new Animal(){
      @Override
      public void eat() {
        System.out.println("Dog eat");
      }

      @Override
      public void sleep() {
        System.out.println("Cat eat");
      }
    };

    dd.eat();
    dd.sleep();

    Animal pp = new Animal() {
      @Override
      public void eat() {
        System.out.println("Pig eat");
      }

      @Override
      public void sleep() {
        System.out.println("Pig sleep");
      }
    };
    pp.eat();
    pp.sleep();      
  }
}

•匿名内部类的使用特点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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
//定义接口
public interface Flyable {
  public abstract void fly();
}


//创建实现类
public class Bird implements Flyable{
  @Override
  public void fly() {
    System.out.println("Bird Fly");
  }
}

public class TestDemo {
  public static void main(String[] args) {
    Bird bd = new Bird();
    bd.fly();
    //Anonymous

    //        new Flyable(){
    //            @Override
    //            public void fly() {
    //                System.out.println("bird fly");
    //            }
    //        };
    Flyable fae = new Flyable(){
      @Override
      public void fly() {
        System.out.println("bird fly");
      }
    };
    fae.fly();
    //调用方法
    /*
        method(new Bird());
  method(new Flyable() {
        @Override
        public void fly() {
            System.out.println("Fly Fly");
        }
    });*/
  }

  public static void method(Flyable ff) {
    ff.fly();
  }
}

总结匿名内部类的格式：

1
2
3
父类名/接口名 对象名 = new 父类名/接口名(){
    //重写父类或接口中所有的抽象方法
};

三. 权限修饰符
Java中一共有4中常见的权限修饰符

1

1
2
3
4
5
6
public class Student {
    public int size;
    protected int grade;
    int age;
    private int height;
}

public protected （空的） private
同一类中 √ √ √ √
同一类中（子类与无关类） √ √ √ X
不同包的子类 √ √ X X
不同包中的无关类 √ X X X
一般来说：
···成员方法和构造方法是public修饰符的
···成员变量是private修饰的
在极个别的情况下，构造方法也可能是private(单例设计模式)

四.代码块
什么叫做代码块：由一对大括号扩起来的一句或多句代码，就是一个代码块

4.1 构造代码块
格式：

1
2
3
4
5
6
public class 类名{
  //代码
  {

  }
}

构造代码块什么时候执行
每次调用构造方法创建对象之前执行

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 Dog {
  int age;
  String name;
  public void bark(){
    System.out.println("Doge");
  }
  //构造方法
  public Dog(){
    System.out.println("Mtehod");
  }

  //构造代码块
  {
    System.out.println("This is Code Block");
  }
}


public class TestDemo09 {
  public static void main(String[] args) {
    //Create Dog Object
    Dog dd = new Dog();
    dd.bark();
  }
}

//输出
This is Code Block
Mtehod
Doge
4.2 静态代码块
格式：

1
2
3
4
5
public class 类名{
  static{
    //静态代码块
  }
}

随着类到加载而执行，且只执行一次，优先于构造方法执行

Demo：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Pig {
  int age;
  String name;
  public void sleep(){
    System.out.println("Pig sleep");
  }
  public Pig(){
    System.out.println("Pig Pig");
  }
  static {
    System.out.println("This is Static Code Block");
  }
}

public class TestDemo10 {
  public static void main(String[] args) {
    Pig pgg = new Pig();
    pgg.sleep();
    //只要使用Pig类，就会加载到内存，即时立即执行静态代码块
    Pig pgg2 = new Pig();
  }
}

输出：
This is Static Code Block
Pig Pig
Pig sleep
Pig Pig

总结：
多态的前提：
a.必须有extend或impelement
b.必须有方法的重写

多态的格式：
父类类型 对象名 = new 子类类型();
接口类型 对象名 = new 实现类类型();

多态调用方法时的特点：编译看父，运行看子
好处：提高代码的扩展性
弊端：多态只能调用子父类共有的方法，无法调用子类特有的方法

向上转型：把子类类型 赋值给 父类类型

Animal an = new Dog();
向下转型：必须有向上转型，才能向下转型

Dog dd = (Dog)an;
关键字:instanceof

if(an instanceof Dog){
Dog dd = (Dog)an;
}
内部类概念：在一个类的内部定义另一个类

匿名内部类：

父类/接口 = new 父类/接口(){
//重写父类或接口中的所有抽象方法
};
修饰符的作用：
public
protected
空的
private

代码块：
构造代码块：
格式：
类中方法外一个大括号

{

}
每次执行

静态代码块：
类中方法外一个static大括号

static{

}
仅执行一次

发表于 更新于

一. final关键字
1.1 final在Java中是一个定义修饰符：修饰类，修饰方法，修饰局部变量，修饰成员变量，修饰引用类型变量
1.2 final的作用和介绍
•final修饰类，不能被继承（只能做子类）。
•final修饰方法，不能被@override
•final修饰局部变量：被final修饰的局部变量，表示该变量只能赋值一次。（在循环框中，每次赋值都是新的局部变量）
•final修饰引用类型变量
final修饰引用类型变量，表示该引用类型变量地址值中表示的地址值不能改变。
注意：final修饰引用变量，只能表示引用变量的地址不能改变，并不代表地址所指向的成员值是可以改变的。
•final修饰成员变量，只能赋值一次，必须赋值。
但是赋值可以有两种选择。
a.定义该成员变量时赋值。
b.或者在构造方法中给该成员变量赋值。

总之，final修饰的成员变量，必须在创建对象之前有值。

final和abstract冲突。

二. static ：静态关键字
2.1 概述：也是一个修饰符，用于修饰类中的成员变量/方法，被static修饰的成员称为静态成员/类成员。

被static修饰的成员，不属于任何一个对象，属于整个类，被所有对象共享(这也是判断是否使用静态关键字的条件)

2.2 定义和格式
•类变量：就是使用static修饰的成员变量，称之为类变量/静态变量
特点：静态变量/类变量，在内存方法中的静态区，只有一份，所有对象共享它
•静态方法：就是使用static修饰的方法，也称为类方法。
特点：正常的方法必须通过对象才能调用，静态方法不需要通过对象，通过类名就可以直接调用

2.3 静态和非静态之间的相互调用
静态成员变量
静态成员方法
与类是同级，只要类加载到内存，静态的成员变量/成员方法就存在（对象不一定存在）

非静态成员变量
非静态成员方法
必须创建对象之后才能访问/调用

生命周期：
静态出现的要比非静态要早

非静态成员方法：
•能访问静态的成员变量
•能访问非静态的成员变量
•能访问静态的成员方法
•能访问非静态的成员方法

静态成员方法：
•能访问静态的成员变量
•能访问静态的成员方法

结论：
a.静态与静态之间，非静态与非静态之间，能相互访问
b.静态可以访问静态，但是静态不能访问非静态
即：静态成员方法只能访问静态成员

2.4 建议调用格式
静态的成员变量
对象名.静态成员变量 [可以访问，但是不建议]
类名.静态成员变量 [建议访问的方式]

静态的成员方法
对象名。静态成员方法 [可以访问，不建议]
类名.静态成员方法 [建议的访问方式]
总结：静态成员虽然可以通过对象名去访问/嗲用，但是更建议通过类名去访问/调用

三. 接口
3.1 概述
也是一种引用类型，接口是方法的集合（接口中主要写方法）
接口是一种公共的规范标准，只要符合规范标准，就可以通用
Java中的接口更多是体现着对行为的抽象。

3.2 定义格式
定义类：class
定义接口：interface
定义枚举：enum
定义注解：@interface

1
2
3
4
5
public interface interfaceName{
  abstract method [JDK 7]
    default method & static method [JDK 8]
    private method & private static method [JDK 9]
}

接口的特点：
•接口用关键字interface修饰
public interface接口名{}
•类实现接口用implements表示
public class 类名 implements 接口名{}
•接口不能实例化
参照多态的方式，通过实现类对象实例化，叫做接口多态。
多态的形式：具体类多态，抽象类多态，接口多态
多态的前提：有继承或实现关系；有方法重写；有父(类/接口)引用指向(子/实现)类对象
•接口的实现类
要么重写接口中所有的抽象方法
要么是抽象类

3.3 接口的使用
a.和abstract method类似，接口也是不能创建对象（new object）的
b.接口也是作为Super interface使用的，用于被其他类 实现 的
c.继承使用extends关键字，实现使用”implements”关键字

使用方式：

1
2
3
4
5
public class 实现类 implements interfaceName{
  //实现类必须重写接口中的所有抽象方法
  //实现类可以选择性重写默认方法但是@override后不能加default
  //静态方法通过类名/接口名直接调用的，没有@override说法
}

3.4 接口的多实现
格式：

1
2
3
4
5
6
public class 实现类 implements interface1,interface2...{
  //实现类需要重写所有接口中的所有抽象方法
  //如果有抽象方法是一样的，那么实现类只需要重写一次
  //如果接口中有一样的默认方法，那么实现类必须重写一次！
  //静态方法没有重写的概念，就算多个接口中有一样的静态方法也不冲突，通过各自所在的接口名调用，没有歧义
}

3.5 实现和继承的优先级问题
一个类 可以在继承一个父类的同时实现多个接口（继承和实现可以同时存在）
格式：

1
2
3
public class 子类/实现类 exttends 父类 implements 接口，接口1{

}

继承的优先级 高于 实现，所以必须先extends 后 implements

3.6 接口的多继承
类和类直接：继承关系，只能单继承，但是可以多层继承
类和接口：实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
接口和接口：继承关系，可以单继承，也可以多继承
格式：

1
2
3
4
5
6
7
8
9
10
11
12
13
public interface MyInter extends Inter1,Inter2{
  MyInter 接口包含了Inter1和Inter2接口所有东西
}

例：
  public class MyClass impelements MyInter{

  }
和
  public class MyClass impelements Inter1,Inter{

  }
等价

3.7 接口中其他成员特点
•接口中，无法定义成员变量，但是可以定义常量（字面值常量，由public static final修饰的常量），其值不可改变，默认使用public static final修饰
【public static final】数据类型 常量名 = 值；【常量名一般纯大写，多个单词用”_”分隔】

•接口中，没有构造方法，也不能创建对象，因为接口主要是对行为进行抽象的，是没有具体存在
一个类如果没有父类，默认继承自Object类

•接口中，没有静态代码块
•【public static final】可省略直接 数据类型 常量名 = 值。但是默认是存在的

•成员方法
只能是抽象方法
默认修饰符public abstract

抽象类和接口的区别：
•成员区别

抽象类 变量，常量；有构造方法；有抽象方法，也有非抽象方法
接口 常量；抽象方法
•关系区别

类与类 继承，单继承
类与接口 实现，可以单实现，也可以多实现
接口与接口 继承，但继承，多继承
•设计理念区别

抽象类 对类抽象，包括属性，行为
接口 对行为抽象，主要是行为
3.8 接口名作为形参和返回值
•方法的形参是接口名，其实需要的是该接哦哭的实现类对象
•方法的返回值是接口名，其实返回的是该接口的实现类对象

总结：
描述final
修饰类：该类不能被继承
修饰方法：该方法不能被重写
修饰变量：该变量只能赋值一次
——局部变量：可以在定义时赋值，也可以先定义后赋值
——成员变量：可以在定义时赋值，也可以在构造方法中赋值
——引用类型变量：表示该引用类型变量的地址不能改变，但是地址内成员的值是可以改变的

static关键字修饰的变量调用方式
类名.成员变量名 【建议的使用方式】

static关键字修饰的方法调用方式
类名.成员() 【建议的使用方式】

接口定义格式：

1
2
3
4
5
public interface interfaceName{
  //抽象方法[最多使用]
  //默认方法
  //静态方法
}

接口实现方式：

1
2
3
4
5
public class 实现类 impelements interfaceName01,02{
  //a.重写所有抽象方法，如果有相同，仅需重写一次
  //b.选择性重写默认方法，如果相同必须重写一次
  //c.静态方法没有重写的概念
}

接口中其他成员特点：
a.没有成员变量，只有常量 【public static final】数据类型 常量名 = 值；
b.没有构造方法，也不能创建对象
c.没有静态代码块

发表于 更新于

一.
匿名对象：没有名字的对象
指new对象，但是不用对象名来接收，但不是没有name属性。
使用场景：
当一个对象我们只需要使用一次时，就可以选择使用匿名对象。

二.继承

2.1
概念：在一个已知类A的基础上，创建新类B的过程，称之为继承
继承是面向对象三大特征之一。可以使得子类具有父类对属性和方法，还可以在子类中重新定义，追加属性和方法

这里类A称为SuperClass（父/基/超）类
这里类B称为SubClass（子/派生）类

格式：

1
2
3
4
5
6
7
8
9
public class SuperClass{
  //member varriable
  //member method
}

public class SubClass extends SuperClass{
  //Automatically inherit the SupeClass's varriavle & method
  //Also can add self varriable & method
}

优势：
a.提高代码复用性(多个类相同对成员可以放到同一个类中)
b.类和类有了关系，提高了代码的维护性，为多态提供前提（如果方法的代码需要修改，修改溢出即可）

弊端：
a.继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时，子类也不得不跟着变化，削弱了子类的独立性

2.2 子类不能继承的内容
a.父类SuperClass的构造方法子类无法继承！！（因为构造方法和类名是一样的）
b.父类SuperClass的私有成员private menmber，子类可以继承，但是不能直接使用。可以使用get和set方法间接使用。

继承后的特点——成员变量
a.当子父类的成员变量名不同时，访问成员变量是没有歧义的，写哪个变量就是哪个变量。
b.当子父类变量同名时，在子类中会根据就近原则，优先访问子类自己的那个成员变量。
c.在子类方法中，使用super.methodName，就会访问SuperClass的成员变量。
就近原则，层层递进：
•子类局部范围找
•子类成员范围找
•父类成员范围找
•如果都没有则报错

super关键字都用法和this关键字用法相似
•this:代表本类成员对象的引用(this关键字指向调用该方法对象，一般是在当前类使用this关键字，使用this常代表本类对象引用)
•super:代表父类存储空间的标识(可以理解为父类对象引用)

继承后的特点——成员方法【重点】
a.当子父类的成员方法名不同时，访问成员方法名是没有歧义的，写哪个方法名就是哪个方法名。
b.当子父类的成员方法同名时，使用子类对象调用该方法，会根据就近原则，优先访问子类自己的那个成员方法。
c.无法通过子类对象使用super调用父类方法。但是可以在子类方法中使用super.methodName()调用父类的同名方法

2.3 重写的概念和应用

重写的概念：
方法的重载（overload）：
在同一个类中，出现了方法名应用，但是参数列表（参数个数｜类型｜顺序）不一样的各种方法，称为方法的重载
方法的重写（override）：
在继承关系sub-super中，子类中出现了一个和父类除了方法体，其他一模一样的方法，称为方法的重写

重写的应用：
子类继承父类时，会继承父类的方法，那么当子类发现继承过来的方法功能不足或不适用时，子类就可以重写该方法，重新实现自己需要的方法即可。

2.4 @override注解
@xxx这种称之为注解，英文名annotation
@override 此注解方法称之为方法重写注解，主要作用就是检查重写的方法是否格式正确（符合父类的除了方法体一模一样）

2.5 方法重写的注意事项
a.方法重写是发生在子父类sub-super之间的关系
b.子类方法重写父类方法时，必须要保证权限大于等于父类的权限（一般来说，父类方法权限=子类方法权限）
Java中四大权限（从大到小依次为：public-protected-default-private）
c.方法重写时，除了方法体，其他都要和父类一模一样。（虽然权限可以不一样，但是一般也写一样的权限）
d.私有方法不能被重写(父类私有成员子类是不能继承的)

2.6 继承后的特点——构造方法
子类中所有的构造方法默认都会访问父类中无参的构造方法，子类初始化之前，一定要先完成父类数据的初始化
构造方法特点介绍：
a.子类无法继承父类的构造方法
b.在子类的任何构造方法的第一行，都有默认一句代码super(),代表调用父类的无参构造。

构造方法总结：
a.子类的任何构造，第一行都会调用父类的无参构造。
如果父类没有无参构造：
•通过super关键字前显示的调用父类的带参构造方法
•在父类中提供一个无参构造方法
b.子类的构造方法第一行，super是默认存在的，可以省略不写，但是默认有的

小结：
a.子类的构造方法中默认有一句super()调用父类的无参构造，我们可以手动改写super(…)调用父类的有参构造，具体哪个构造，由参数决定
b.super(…)和this(…)必须在第一行，所有不能重复重写
c.super(…)和this(…)调用父的构造和子类自己的其他构造，具体哪个构造由参数决定
d.super(…)调用父类的有参构造，初始化父类继承的成员变量。
e.this(…)调用子类的其他构造方法

关键字 访问成员变量 访问构造方法 访问成员方法
this this.成员变量，访问本类成员变量 this(…)访问本类构造方法 this.成员方法(…) 访问本类成员方法
super super.成员变量，访问父类成员变量 super(…)访问父类构造方法 super.成员方法(…) 访问父类成员方法
2.7 Java中继承的特点
a.Java只支持单继承，不支持多继承。（一个类最多只有一个super）
b.一个类可以有多个子类（一个super可以有多个sub）
c.可以多层继承（sub有自己的super，相对还有super的super）
总结：Java只支持单继承，但是可以多层继承。

三. 抽象类
3.1 抽象类的概念和引入

抽象类的概念：
a.抽象方法：只有方法的声明，没有方法的实现(即没有方法体)
b.含有抽象方法的类，就是一个抽象类

使用格式
•抽象方法
public abstract 返回值类 方法名（参数列表）；
•抽象类
public abstract class 类名{
抽象方法
正常方法
}
注意：抽象类不能创建对象，总是作为父类。
抽象类不能创建对象，需要有子类继承它，并且重写所有抽象类后，该子类才能创建对象。

3.2抽象类的特征：
抽象类具备了含有抽象方法的能力，同时失去了创建对象的能力。
注意事项：
a.抽象类不能创建对象
b.抽象类有构造方法，用于初始化类中的成员变量
c.抽象类中不一定含有抽象方法，有抽象方法的类一定是抽象类（一般来说，抽象类中是有抽象方法的）
d.抽象类的子类必须重写抽象类的所有抽象方法，否则子类还是一个抽象类
e.抽象类存在的意义就是被子类继承的，为子类提供模版

3.3 抽象类的成员特点
•成员变量：可以是变量，也可以是常量
•构造方法：有构造方法，本身不能实例化，用于子类访问父类数据的初始化
•成员方法：
a.可以有抽象方法：限定子类必须完成某些动作
b.也可以有非抽象方法：提高代码复用性

3.4 抽象类名作为形参和返回值
•方法的形参是抽象类名，其实需要的是该抽象类的子类对象
•方法的返回值是抽象类名，其实返回的是该抽象类的子类对象

3.5 模版设计模式

总结：
继承：
a.继承的格式
public class 子类 extends 父亲{}
b.不能继承的内容
I.构造方法不能继承
II.私有成员子类可以继承但是不能直接使用（间接使用，通过get/set方法使用）
c.继承后成员变量和成员方法的特点：
I.不同名，没有歧义
II.同名时在子类中优先调用子类自己的成员
III.可以使用关键字
super.变量名 访问父类的同名成员变量
super.方法名() 访问父类的同名成员方法
d.方法的重写
方法的重写：在继承关系中，子类有一个和父类除了方法体其他一模一样的方法，该方法称为重写
什么时候需要重写：
当子类继承父类的方法后，发现父类方法不实用，子类就可以重写该方法
重写时可以用override帮助检查格式是否正确
e.super(…)
用于子类的构造方法第一行，调用父类的构造方法，具体是哪一个构造
由super(参数)中的参数决定
f.this(…)
用于本类的构造方法第一行，调用本类的构造方法，具体是哪一个构造
由this(参数)中的参数决定
g.Java的继承特点：
只支持单继承，但是支持多层继承
抽象类：
a.抽象方法格式：
public abstract void method();
抽象类格式：
public abstract class className{可能有抽象方法，可以没有抽象方法}
b.抽象类的使用方式：
使用子类继承抽象类，重写所有抽象方法后，子类才能创建对象。
c.抽象类的意义：
给子类继承的，为子类提供的模版（模版设计模式）

发表于 更新于

一.数据输入
1.1 Scanner使用基本步骤
①导包
import java.util.Scanner;
导包的动作必须出现在定义上面。
②创建对象
Scanner sc = new Scanner(System.in);
上面这个格式里，只有变量名sc可以变，其他都不允许变。
③接收数据
int i = sc.nextInt();
上面这个格式里，只有变量名i可以变，其他都不允许变。

发表于 更新于

一.API
1.1 API (Application Programming Interface) 概述：应用程序编程接口

Java API：指的就是JDK中提供的各种功能的Java类
这些类将底层的实现封装了起来，可以通过帮助文档来学习这些API如何使用

1.2 如何使用帮助文档：
①打开使用版本的JDK文档
②索引框输入要查询的类
③查看类在哪个包下
④看类的描述
⑤看构造方法
⑥看成员方法

注意：调用方法时，如果方法有明确的返回值，可以用变量接收

二. String
2.1 String 概述：
String类在java.lang 包下，使用时不需要导入包。

String类代表字符串，Java程序中所有的字符串文字(例如”abc”)都被实现为此类的实例
也就是说，Java程序中所有的双引号字符串，都是String类的对象

字符串的特点:

字符串不可变，它们的值在创建后不能被更改
虽然String值不可变，但是它们可以被共享
字符串效果上相当于字符数组(char[] ,JDK8及之前是字符数组，JDK9之后是字节数组),但是底层原理是字节数组(byte[] )
2.2 String的常用构造方法：

方法名 说明
public String() 创建一个空白字符串对象，不含任何内容
public String(char[] chs) 根据字符组的内容，来创建字符串对象
public String(byte[] bys) 根据字节组的内容，来创建字符串对象
String s = “abc” 直接赋值的方式创建字符串对象，内容就是abc

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class AIO_ServerSocketChannel {
  public static void main(String[] args){
    String s1 = new String();
    System.out.println(s1);//无内容，因为未赋值

    char[] chs = {'a','b','c'};
    String s2 = new String(chs);
    System.out.println(s2);//abc

    byte[] bys = {97,98,99};
    String s3 = new String(bys);
    System.out.println(s3);//abc,因为使用的是ASCII码

    String s4 = "abc"
      System.out.println(s4);//abc
  }
}

推荐直接使用赋值方式得到字符串对象

2.3 String对象的特点
1)通过new创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值不同

char[] chs ={‘a’,’b’,’c’};
String s1 = new String(chs);
String s2 = new String(chs);
在上述代码中，JVM会熟悉创建一个字符数组，然后每次new的时候都会有一个新的地址，只不过s1和s2参考的字符串内容都是相同的

2)以 “” 方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM都只会建立一个String对象，并在字符串池中维护

String s3 = “abc”;
String s4 = “abc”;
在上述代码中，针对第一行代码，JVM会建立一个String对象放在字符串池中，并给s3参考；
第二行让s4直接参考字符串池中的String对象，也就是说它们本质上还是同一个对象

内存过程：

1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args){
  char[] chs ={'a','b','c'};
  String s1 = new String(chs);
  String s2 = new String(chs);
  System.out.println(s1 == s2);//false

  String s3 = "abc";
  String s4 = "abc";
  System.out.println(s3 == s4);//true
  System.out.println(s1 == s3);//false
}

栈内存：
方法main
char[] chs 假设地址001
String s1 假设地址002
String s2 假设地址003
String s3 假设地址004
String s4 假设地址004

堆内存：
new char[3]
001
0 ‘a’
1 ‘b’
2 ‘c’

new String()
002
ref 001

new String()
003
ref 001

常量池
004 abc 赋值给s3与s4

2.4 字符串的比较
使用 == 做比较

基本类型：比较的是数据值是否相同
引用类型：比较的是地址值是否相同
字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫:equals()

public boolean equals(Object anObject);将此字符串与指定对象进行比较。由于比较的是字符串对象，所以参数直接传递一个字符串
遍历字符串，首先要能够获取到字符串中的每一个字符

public char charAt(int index);返回指定索引处的char值，字符串的索引也是从0开始的
遍历字符串，获取字符串的长度
public int length();返回此字符串的长度
数组的长度：数组名.length
字符串的长度：字符串对象.length()
遍历字符串通用格式：
1
2
3
for(int i=0;i<s.length();i++ ){
s.charAt(i);//就是指定索引处的字符值
}
•大写字母：ch>=’A’ && ch <= ‘Z’
•小写字母：ch>=’a’ && ch <= ‘z’
•数字：ch>=’0’ && ch <= ‘9’

2.5 通过帮助文档查看String中的方法

方法名 说明
public boolean equals(Object anObject) 比较字符串的内容，严格区分大小写(用户名&密码)
public char charAt(int Index) 返回索引处的char值
public int length() 返回此字符串的长度
三. StringBuilder
3.1 概述
StringBuilder是一个可变的字符串类，可以把它当作一个容器。
这里的可变指的是StringBuilder对象中的内容是可变的

String和StringBuilder的区别：

String：内容是不可变的
StringBuilder：内容是可变的
如果对字符串String进行拼接操作，每次拼接都会构建一个新的String对象，耗费时间与内存空间。
因此使用StringBuilder可类可以解决这个问题。

3.2 StringBuilder的构造方法

方法名 说明
public StringBuilder() 创建一个空白可变字符串对象，不含任何内容
public StringBuilder(String str) 根据字符串内容，创建可变字符串对象
public StringBuilder(int Capacity) 构造一个没有字符的字符串构建器，以及由capcacity参数指定的初始容量
public StringBuilder(CharSequence seq) 构造一个字符串构建器，其中包含与指定的CharSequence相同的字符
3.3 StringBuilder的添加和反转方法

方法名 说明
public StringBuilder append(任意类型) 添加数据，并返回数据本身
public StringBuilder reserve() 返回相反的字符序列

1
2
3
4
5
6
7
8
9
10
11
public class SBDemo01{
  public static void main(String[] args){
    StringBuilder sb = new StringBuilder();

    sb.append("a").append("b");//链式编程
    System.out.println(sb);//ab

    sb.reserve();
    System.out.println(sb);//ba
  }
}

3.4 StringBuilder 和 String 相互转换
a.从StringBuilder转换为String
public String toString();通过toString()就可以实现把StringBuilder转换为String

b.从String转换为StringBuilder
public StringBuilder(String s);通过构造方法就可以把String转换为StringBuilder

1
2
3
4
5
6
7
8
9
10
11
public class SBDemo01{
  public static void main(String[] args){
    StringBuilder sb = new StringBuilder();

    sb.append("abc");
    String s = sb.toString(s);

    String t = "hello";
    StringBuilder new_sb = new StringBuilder(s);
  }
}

3.5 通过帮助文档查看 StringBuilder 中的方法

方法名 说明
public StringBuilder append(任意类型) 添加数据，并返回数据本身
public StringBuilder reserve() 返回相反的字符序列
public String toString() 通过toString()就可以实现把StringBuilder转换为String