Java学习笔记（二）

1. Java抽象类：

• 抽象类和抽象方法都必须用abstract修饰，而且抽象方法不能有方法体
• 抽象类不能被实例化，即便这个抽象类没有包含抽象方法
• 抽象类的构造器不能用于创建实例，只能用于被其子类调用
• 含有抽象方法的类（包括直接定义一个抽象方法；继承了一个抽象父类但没有完全实现父类包含的抽象方法；以及实现了一个接口，但没有完全实现接口包含的抽象方法三种情况）只能被定义为抽象类
• 注意：
• abstract修饰的方法只能被子类复写并实现，而final修饰的方法不允许子类复写，故abstract和final永远不要一起使用
• abstract不能用于修饰属性和局部变量，也不能用于修饰构造器
• abstract也不能与private同时使用（private修饰的变量不会被子类重写）

2. 局部内部类、变量只在方法内有效，它的上一级程序单元是方法而不是类，故不能用static和访问控制权限符修饰

3. HashSet:

•  1 import java.util.*;
   2
   3 //A类的equals方法总是返回ture，但没有重写切hashCode方法
   4 class A{
   5     public boolean equals(Object obj){
   6         return true;
   7     }
   8 }
   9
  10 //B类的hashCode方法总是返回1，但没有重写其equals方法
  11 class B{
  12     public int hashCode(){
  13         return 1;
  14     }
  15 }
  16
  17 //C类的hashCode总是返回2，有重写其equals方法
  18 class C{
  19     public int hashCode(){
  20         return 2;
  21     }
  22
  23     public boolean equals(Object obj){
  24         return true;
  25     }
  26 }
  27
  28 public class TestSet
  29 {
  30     public static void main(String[] args)
  31     {
  32         HashSet books = new HashSet();
  33         books.add(new A());
  34         books.add(new A());
  35         books.add(new B());
  36         books.add(new B());
  37         books.add(new C());
  38         books.add(new C());
  39         System.out.println(books);
  40     }
  41 }
  42
  43
  44 /*
  45 [[email protected], [email protected], [email protected], [email protected], [email protected]]
  46 请按任意键继续. . .
  47 */

• HashSet通过同时判断equals和hashCode来区别重复元素（如果equals和hashCode对比返回都是true， 则为重复元素）
• HashSet储存是无序的，是根据hashCode的值来对应一个储存位置来存储元素（其实hashCode就相当于HashSet的索引，它通过这个索引来找到对应元素，速度很快）
• 重写hashCode的规则：
• 当两个对象通过equals方法比较返回true时，这两个对象的hashCode的值应该相等
• 对象中用作equals比较标准的属性，都应该用来计算hashCode的值
• 向HashSet中添加一个个可变对象，并改变其值可能会产生的问题：

  •  1 import java.util.*;
     2 class R
     3 {
     4     int count;
     5     public R(int count){
     6         this.count = count;
     7     }
     8
     9     public String toString(){
    10         return "R(count 属性 ：" + count + " )";
    11     }
    12
    13     public boolean equals(Object obj){
    14         if(obj instanceof R){
    15             R r = (R)obj;
    16             if(r.count == this.count){
    17                 return true;
    18             }
    19         }
    20         return false;
    21     }
    22
    23     public int hashCode(){
    24         return this.count;
    25     }
    26 }
    27
    28
    29 public class TestHashSet
    30 {
    31     public static void main(String[] args)
    32     {
    33         HashSet hs = new HashSet();
    34         hs.add(new R(5));
    35         hs.add(new R(-3));
    36         hs.add(new R(9));
    37         hs.add(new R(253));
    38
    39         //打印HashSet集合
    40         System.out.println(hs);
    41
    42         //取出第一个元素
    43         Iterator it = hs.iterator();
    44         it.next();
    45         R first = (R)it.next();
    46         //为第一个元素的count赋值
    47         first.count = -3;
    48
    49         //再次输出HashSet集合,集合有重复元素
    50         System.out.println(hs);
    51
    52         //删除count为-3的R对象
    53         hs.remove(new R(-3));
    54
    55         //可以看到被删除了一个R元素
    56         System.out.println(hs);
    57
    58         //输出false
    59         System.out.println("hs是否包含count为-3的R对象？" + hs.contains(new R(-3)));
    60         //输出false
    61         System.out.println("hs是否包含count为5的R对象？" + hs.contains(new R(5)));
    62     }
    63 }
    64
    65 /*
    66 [R(count 属性 ：-3 ), R(count 属性 ：5 ), R(count 属性 ：9 ), R(count 属性 ：253 )]
    67 [R(count 属性 ：-3 ), R(count 属性 ：-3 ), R(count 属性 ：9 ), R(count 属性 ：253 )]
    68 [R(count 属性 ：-3 ), R(count 属性 ：9 ), R(count 属性 ：253 )]
    69 hs是否包含count为-3的R对象？false
    70 hs是否包含count为5的R对象？false
    71 请按任意键继续. . .
    72 */

• 说明：
• 第二个-3虽然值为-3，但它却是放在原来值为-5的位置，删除时不会被删除，而且这个时候equals和hashCode永远不能保持一致，之后这个HashSet的访问将会存在问题
• 注意：当向HashSet中添加可变对象时，必须十分小心，如果修改HashSet集合中的对象，有可能导致该对象与集合中的其他对象相等，从而导致HashSet无法准确访问该对象

• 自然排序：Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，实现了该接口就可以比较大小，常见类已经实现了该方法，TreeSet根据该方法来进行排序
• 如果试图将一个对象添加进TreeSet，则该对象的类必须实现Comparable接口，否则程序将会抛出异常（向TreeSet里添加对象时，只有第一个元素可以不实现Comparable接口，但这不是一个好做法，当取出该元素是会抛出ClassCastException）
• 向TreeSet里添加的也应该是同一类型的对象，否则也会抛出ClassCastException（实现compareTo(Object obj)方法时也应该将obj强制转换为相同类型来进行比较）
• 判断重复元素的标准：
• equals方法返回true
• compareTo方法返回0
• 如果两个对象的equals方法返回true，则应该保证compareTo方法返回0；

•  1 import java.util.*;
   2
   3 public class TestLinkedList
   4 {
   5     public static void main(String[] args)
   6     {
   7         LinkedList books = new LinkedList();
   8         //将字符串元素加入队列的尾部
   9         books.offer("Robbin1");
  10         //将一个字符串元素入栈
  11         books.push("Robbin2");
  12         //将字符串元素添加到队列的头部
  13         books.offerFirst("Robbin3");
  14         for(int i = 0; i < books.size(); i++){
  15             System.out.println(books.get(i));
  16         }
  17
  18         //访问并不删除队列的第一个元素
  19         System.out.println(books.peekFirst());
  20         //访问并不删除队列的最后一个元素
  21         System.out.println(books.peekLast());
  22         //采用出栈的方式将第一个元素pop出队列
  23         System.out.println(books.pop());
  24         //下面输出将看到第一个元素被删除
  25         System.out.println(books);
  26         //访问并删除队列的最后一个元素
  27         System.out.println(books.pollLast());
  28         System.out.println(books);
  29     }
  30 }
  31
  32 /*
  33 Robbin3
  34 Robbin2
  35 Robbin1
  36 Robbin3
  37 Robbin1
  38 Robbin3
  39 [Robbin2, Robbin1]
  40 Robbin1
  41 [Robbin2]
  42 请按任意键继续. . .
  43 */

• LinkedList兼备List，stack和双向队列的功能，一般与ArrayList没有太大性能上的差异，但在一些性能敏感的地方要注意选择
• 关于List集合的建议：
• 如果需要遍历List集合元素，对于ArrayList和vector集合，则应该使用随机访问方法（get）来遍历集合元素，这样性能更好。对于LinkedList集合，则应该采用迭代器（Iterator）来遍历集合元素；
• 如果需要经常执行插入、删除操作来改变List集合的大小，则应该使用LinkedList集合而不是ArrayList。使用ArrayList、vector集合将需要重新分配内部数组大小，其时间开销常常是使用LinkedList的时间开销的几十倍，效果更差;
• 如果有多条线程同时访问List集合中的元素，可以考录vector这个同步实现;

排序操作：

• •  1 import java.util.*;
     2 public class TestSort
     3 {
     4     public static void main(String[] args)
     5     {
     6         ArrayList nums = new ArrayList();
     7         nums.add(2);
     8         nums.add(-5);
     9         nums.add(3);
    10         nums.add(0);
    11         nums.add(1);
    12
    13         System.out.println(nums);
    14         //将List集合元素的次序反转
    15         Collections.reverse(nums);
    16         System.out.println(nums);
    17         //将List集合元素按自然排序排序
    18         Collections.sort(nums);
    19         System.out.println(nums);
    20         //将List集合元素按随机顺序排序
    21         Collections.shuffle(nums);
    22         //每次输出的次序不固定
    23         System.out.println(nums);
    24
    25     }
    26 }
    27
    28 /*
    29 输出结果：[2, -5, 3, 0, 1]
    30 [1, 0, 3, -5, 2]
    31 [-5, 0, 1, 2, 3]
    32 [2, 1, 0, 3, -5]
    33 请按任意键继续. . .
    34 */

  •   1 import java.util.*;
      2 import java.lang.reflect.Array;
      3 public class ShowHand
      4 {
      5     //定义该游戏最多支持几个玩家
      6     private final int PLAY_NUM = 5;
      7     //定义扑克牌的所有花色
      8     //下面是四个特殊字符，会在控制台打印出方块，草花， 红心，黑桃
      9     private String[] types = {"\4 ", "\5 ", "\3 ", "\6 "};
     10     private String[] values = {"2 ", "3 ", "4 ", "5 ", "6 ", "7 ", "8 ", "9 ", "10 ", "J ", "Q ", "K ", "A "};
     11
     12     //cards是一局游戏中剩下的扑克牌
     13     private List<String> cards = new LinkedList<String>();
     14     //定义所有玩家
     15     private String[] players = new String[PLAY_NUM];
     16     //所有玩家手上的扑克牌
     17     private List<String>[] playersCards = new List[PLAY_NUM];
     18
     19     /**
     20     * 初始化扑克牌，放入52张扑克牌，并且使用shuffle方法将他们按随机顺序排序
     21     */
     22     public void initCards(){
     23         for(int i = 0; i < types.length; i++){
     24             for(int j = 0; j < values.length; j++){
     25                 cards.add(types[i] + values[j]);
     26             }
     27         }
     28         //随机排序
     29         Collections.shuffle(cards);
     30
     31     }
     32
     33
     34     /**
     35     * 初始化玩家，为每个玩家分配用户名
     36     */
     37     public void initPlayer(String... names){
     38         if(names.length > PLAY_NUM || names.length < 2){
     39             //校检玩家数量，此时处理异常更合理
     40             System.out.println("玩家数量不对");
     41             return ;
     42         }else{
     43             //初始化玩家用户名
     44             for(int i = 0; i < names.length; i++){
     45                 players[i] = names[i];
     46             }
     47         }
     48     }
     49
     50     /**
     51     * 初始化玩家手上的扑克牌,开始游戏时每个玩家手上的扑克牌为空，
     52     * 程序使用一个长度为0的LinkedList表示。
     53     */
     54     public void initPlayerCards(){
     55         for(int i = 0; i < players.length; i++){
     56             if(players[i] != null && !players[i].equals("")){
     57                 playersCards[i] = new LinkedList<String>();
     58             }
     59         }
     60     }
     61
     62     /**
     63     * 输出全部扑克牌，该方法没有实际作用，仅用作测试
     64     */
     65     public void showAllCards(){
     66         for(String card : cards){
     67             System.out.println(card);
     68         }
     69     }
     70
     71     /**
     72     * 派扑克牌
     73     * @param first 最先派给谁
     74     */
     75     public void deliverCard(String first){
     76         //调用ArrayUtils工具类的search方法。查询出制定元素在数组中的索引
     77         //int firstPos = ArrayUtils.search(players, first);
     78         int firstPos = 0;
     79         //依次给位于该指定玩家之后的每个玩家派扑克牌
     80         for(int i = firstPos; i < PLAY_NUM; i++){
     81             if(players[i] != null){
     82                 playersCards[i].add(cards.get(0));
     83                 cards.remove(0);
     84             }
     85         }
     86         //依次给位于该指定玩家之前的每个玩家派扑克牌
     87         for(int i = 0; i < firstPos; i++){
     88             if(players[i] != null){
     89                 playersCards[i].add(cards.get(0));
     90                 cards.remove(0);
     91             }
     92         }
     93     }
     94
     95     /**
     96     * 输出玩家手上的扑克牌
     97     * 实现该方法时，应该控制每个玩家看不到别人的第一张牌， 但此处没有增加该功能
     98     */
     99     public void showPlayerCards(){
    100         for(int i = 0; i < PLAY_NUM; i++){
    101             //当玩家不为空时
    102             if(players[i] != null){
    103                 System.out.print(players[i] + " : ");
    104                 //便利玩家手上的牌
    105                 for(String card : playersCards[i]){
    106                     System.out.print(card + "\t");
    107                 }
    108                 System.out.print("\n");
    109             }
    110         }
    111     }
    112     public static void main(String[] args)
    113     {
    114         ShowHand sh = new ShowHand();
    115         sh.initPlayer("电脑玩家", "ME");
    116         sh.initCards();
    117         sh.initPlayerCards();
    118         //下面测试所有扑克牌，没有实际作用
    119         sh.showAllCards();
    120         System.out.println("---------------------------------------------------------------------");
    121         //下面从ME开始派牌
    122         sh.deliverCard("ME");
    123         sh.showPlayerCards();
    124
    125         sh.deliverCard("电脑玩家");
    126         sh.showPlayerCards();
    127     }
    128 }
    129
    130
    131 /*
    132  5
    133  2
    134  9
    135  6
    136  K
    137  K
    138  8
    139  7
    140  6
    141  8
    142  4
    143  6
    144  8
    145  A
    146  2
    147  2
    148  4
    149  3
    150  3
    151  J
    152  9
    153  A
    154  7
    155  10
    156  3
    157  Q
    158  6
    159  Q
    160  J
    161  9
    162  4
    163  A
    164  5
    165  4
    166  10
    167  K
    168  10
    169  8
    170  9
    171  10
    172  7
    173  Q
    174  A
    175  K
    176  J
    177  2
    178  5
    179  7
    180  Q
    181  5
    182  3
    183  J
    184 ---------------------------------------------------------------------
    185 电脑玩家 :  5
    186 ME :  2
    187 电脑玩家 :  5   9
    188 ME:  2         6
    189 请按任意键继续. . .
    190 */

• 查找替换操作：
• static int binarySearch (List list, Object key)：使用二分法搜索指定List集合，以获得指定对象在List集合中的索引（如果该方法要能正常工作，必须保证List集合元素已经处于有序状态）
• static Object max(Collection coll)：更具元素的自然顺序，返回给定集合中的最大元素
• static Object max(Collection coll, Comparator comp)：根据指定Comparator产生的顺序，返回指定集合的最大元素
• static Object min(Collection coll)
• static Object min(Collection coll, Comparator comp)
• static void fill(List list, Object obj)：使用指定元素obj替换指定List集合中的所有元素
• static int frequency(Collection c, Object o)：返回指定List集合中的指定对象的元素数量
• static int indexOfSubList(List source, List target)：返回List对象在母List对象中第一次出现的位置索引；如果母List中没有出现这样的子List，则返回-1
• static int lastIndexOfSubList(List source, List target)
• static boolean replaceAll(List list, Object oldVal, Object newVal)：使用一个新值newVal替换List对象所有的旧值oldVal

•  1 import java.util.*;
   2 public class TestSearch
   3 {
   4     public static void main(String[] args)
   5     {
   6         ArrayList nums = new ArrayList();
   7         nums.add(2);
   8         nums.add(-5);
   9         nums.add(3);
  10         nums.add(0);
  11
  12         System.out.println(nums);
  13         //输出最大元素,将输出3
  14         System.out.println(Collections.max(nums));
  15         //输出最小元素,将输出-5
  16         System.out.println(Collections.min(nums));
  17         //将nums中的0用1来替代
  18         Collections.replaceAll(nums, 0, 1);
  19         System.out.println(nums);
  20         //判断-5在集合nums中出现的次数，将输出1
  21         System.out.println(Collections.frequency(nums, -5));
  22         //对nums集合排序
  23         Collections.sort(nums);
  24         System.out.println(nums);
  25         //只有排序后的List集合才可用二分法查询,输出3
  26         System.out.println(Collections.binarySearch(nums, 3));
  27     }
  28 }
  29
  30 /*
  31 [2, -5, 3, 0]
  32 3
  33 -5
  34 [2, -5, 3, 1]
  35 1
  36 [-5, 1, 2, 3]
  37 3
  38 请按任意键继续. . .
  39
  40 */

• 同步控制：(Java常用集合框架中推荐使用的三么实现类：HashSet、ArrayList和HashMap都是线程不安全的。如果有多条线程访问它们，而且有超过一条的线程试图改变它们，则可能出现错误。Collections提供了多个静态方法用于创建同步集合)

  •  1 import java.util.*;
     2 public class TestSynchronized
     3 {
     4     public static void main(String[] args)
     5     {
     6         //下面程序创建了四个同步集合对象
     7         Collection c = Collections.synchronizedCollection(new ArrayList());
     8         List list = Collections.synchronizedList(new ArrayList());
     9         Set s = Collections.synchronizedSet(new HashSet());
    10         Map m = Collections.synchronizedMap(new HashMap());
    11     }
    12 }

• 设置不可变集合：
  • emptyXxx()
  • singletonXxx()
  • unmodifiableXxx()