Java学习笔记（二）

1. Java抽象类：

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

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

---

3. HashSet:

• import java.util.*;
  
  //A类的equals方法总是返回ture，但没有重写切hashCode方法
  class A{
      public boolean equals(Object obj){
          return true;
      }
  }
  
  //B类的hashCode方法总是返回1，但没有重写其equals方法
  class B{
      public int hashCode(){
          return 1;
      }
  }
  
  //C类的hashCode总是返回2，有重写其equals方法
  class C{
      public int hashCode(){
          return 2;
      }
  
      public boolean equals(Object obj){
          return true;
      }
  }
  
  public class TestSet 
  {
      public static void main(String[] args) 
      {
          HashSet books = new HashSet();
          books.add(new A());
          books.add(new A());
          books.add(new B());
          books.add(new B());
          books.add(new C());
          books.add(new C());
          System.out.println(books);
      }
  }
  
  
  /*
  [B@1, B@1, C@2, A@2a139a55, A@15db9742]
  请按任意键继续. . . 
  */

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

  • import java.util.*;
    class R
    {
        int count;
        public R(int count){
            this.count = count;
        }
    
        public String toString(){
            return "R(count 属性 ：" + count + " )";
        }
    
        public boolean equals(Object obj){
            if(obj instanceof R){
                R r = (R)obj;
                if(r.count == this.count){
                    return true;
                }
            }
            return false;
        }
    
        public int hashCode(){
            return this.count;
        }
    }
    
    
    public class TestHashSet 
    {
        public static void main(String[] args) 
        {
            HashSet hs = new HashSet();
            hs.add(new R(5));
            hs.add(new R(-3));
            hs.add(new R(9));
            hs.add(new R(253));
    
            //打印HashSet集合
            System.out.println(hs);
    
            //取出第一个元素
            Iterator it = hs.iterator();
            it.next();
            R first = (R)it.next();
            //为第一个元素的count赋值
            first.count = -3;
    
            //再次输出HashSet集合,集合有重复元素
            System.out.println(hs);
    
            //删除count为-3的R对象
            hs.remove(new R(-3));
    
            //可以看到被删除了一个R元素
            System.out.println(hs);
    
            //输出false
            System.out.println("hs是否包含count为-3的R对象？" + hs.contains(new R(-3)));
            //输出false
            System.out.println("hs是否包含count为5的R对象？" + hs.contains(new R(5)));
        }
    }
    
    /*
    [R(count 属性 ：-3 ), R(count 属性 ：5 ), R(count 属性 ：9 ), R(count 属性 ：253 )]
    [R(count 属性 ：-3 ), R(count 属性 ：-3 ), R(count 属性 ：9 ), R(count 属性 ：253 )]
    [R(count 属性 ：-3 ), R(count 属性 ：9 ), R(count 属性 ：253 )]
    hs是否包含count为-3的R对象？false
    hs是否包含count为5的R对象？false
    请按任意键继续. . .    
    */

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

---

4. TreeSet（是SortedSet接口的唯一实现）

• 自然排序：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；

---

5. LinkedList

• import java.util.*;
  
  public class TestLinkedList  
  {
      public static void main(String[] args) 
      {
          LinkedList books = new LinkedList();
          //将字符串元素加入队列的尾部
          books.offer("Robbin1");
          //将一个字符串元素入栈
          books.push("Robbin2");
          //将字符串元素添加到队列的头部
          books.offerFirst("Robbin3");
          for(int i = 0; i < books.size(); i++){
              System.out.println(books.get(i));
          }
  
          //访问并不删除队列的第一个元素
          System.out.println(books.peekFirst());
          //访问并不删除队列的最后一个元素
          System.out.println(books.peekLast());
          //采用出栈的方式将第一个元素pop出队列
          System.out.println(books.pop());
          //下面输出将看到第一个元素被删除
          System.out.println(books);
          //访问并删除队列的最后一个元素
          System.out.println(books.pollLast());
          System.out.println(books);
      }
  }
  
  /*
  Robbin3
  Robbin2
  Robbin1
  Robbin3
  Robbin1
  Robbin3
  [Robbin2, Robbin1]
  Robbin1
  [Robbin2]
  请按任意键继续. . .
  */

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

 

 

---

6. 操作集合的工具类

排序操作：

• • import java.util.*;
    public class TestSort 
    {
        public static void main(String[] args) 
        {
            ArrayList nums = new ArrayList();
            nums.add(2);
            nums.add(-5);
            nums.add(3);
            nums.add(0);
            nums.add(1);
    
            System.out.println(nums);
            //将List集合元素的次序反转
            Collections.reverse(nums);
            System.out.println(nums);
            //将List集合元素按自然排序排序
            Collections.sort(nums);
            System.out.println(nums);
            //将List集合元素按随机顺序排序
            Collections.shuffle(nums);
            //每次输出的次序不固定
            System.out.println(nums);
    
        }
    }
    
    /*
    输出结果：[2, -5, 3, 0, 1]
    [1, 0, 3, -5, 2]
    [-5, 0, 1, 2, 3]
    [2, 1, 0, 3, -5]
    请按任意键继续. . .
    */

  • import java.util.*;
    import java.lang.reflect.Array;
    public class ShowHand 
    {
        //定义该游戏最多支持几个玩家
        private final int PLAY_NUM = 5;
        //定义扑克牌的所有花色
        //下面是四个特殊字符，会在控制台打印出方块，草花， 红心，黑桃
        private String[] types = {"4 ", "5 ", "3 ", "6 "};
        private String[] values = {"2 ", "3 ", "4 ", "5 ", "6 ", "7 ", "8 ", "9 ", "10 ", "J ", "Q ", "K ", "A "};
    
        //cards是一局游戏中剩下的扑克牌
        private List<String> cards = new LinkedList<String>();
        //定义所有玩家
        private String[] players = new String[PLAY_NUM];
        //所有玩家手上的扑克牌
        private List<String>[] playersCards = new List[PLAY_NUM];
    
        /**
        * 初始化扑克牌，放入52张扑克牌，并且使用shuffle方法将他们按随机顺序排序
        */
        public void initCards(){
            for(int i = 0; i < types.length; i++){
                for(int j = 0; j < values.length; j++){
                    cards.add(types[i] + values[j]);
                }
            }
            //随机排序
            Collections.shuffle(cards);
    
        }
    
    
        /**
        * 初始化玩家，为每个玩家分配用户名
        */
        public void initPlayer(String... names){
            if(names.length > PLAY_NUM || names.length < 2){
                //校检玩家数量，此时处理异常更合理
                System.out.println("玩家数量不对");
                return ;
            }else{
                //初始化玩家用户名
                for(int i = 0; i < names.length; i++){
                    players[i] = names[i];
                }
            }
        }
    
        /**
        * 初始化玩家手上的扑克牌,开始游戏时每个玩家手上的扑克牌为空，
        * 程序使用一个长度为0的LinkedList表示。
        */
        public void initPlayerCards(){
            for(int i = 0; i < players.length; i++){
                if(players[i] != null && !players[i].equals("")){
                    playersCards[i] = new LinkedList<String>();
                }
            }
        }
    
        /**
        * 输出全部扑克牌，该方法没有实际作用，仅用作测试
        */
        public void showAllCards(){
            for(String card : cards){
                System.out.println(card);
            }
        }
    
        /**
        * 派扑克牌
        * @param first 最先派给谁
        */
        public void deliverCard(String first){
            //调用ArrayUtils工具类的search方法。查询出制定元素在数组中的索引
            //int firstPos = ArrayUtils.search(players, first);
            int firstPos = 0;
            //依次给位于该指定玩家之后的每个玩家派扑克牌
            for(int i = firstPos; i < PLAY_NUM; i++){
                if(players[i] != null){
                    playersCards[i].add(cards.get(0));
                    cards.remove(0);
                }
            }
            //依次给位于该指定玩家之前的每个玩家派扑克牌
            for(int i = 0; i < firstPos; i++){
                if(players[i] != null){
                    playersCards[i].add(cards.get(0));
                    cards.remove(0);
                }
            }
        }
    
        /**
        * 输出玩家手上的扑克牌
        * 实现该方法时，应该控制每个玩家看不到别人的第一张牌， 但此处没有增加该功能
        */
        public void showPlayerCards(){
            for(int i = 0; i < PLAY_NUM; i++){
                //当玩家不为空时
                if(players[i] != null){
                    System.out.print(players[i] + " : ");
                    //便利玩家手上的牌
                    for(String card : playersCards[i]){
                        System.out.print(card + "	");
                    }
                    System.out.print("
    ");
                }
            }
        }
        public static void main(String[] args) 
        {
            ShowHand sh = new ShowHand();
            sh.initPlayer("电脑玩家", "ME");
            sh.initCards();
            sh.initPlayerCards();
            //下面测试所有扑克牌，没有实际作用
            sh.showAllCards();
            System.out.println("---------------------------------------------------------------------");
            //下面从ME开始派牌
            sh.deliverCard("ME");
            sh.showPlayerCards();
    
            sh.deliverCard("电脑玩家");
            sh.showPlayerCards();
        }
    }
    
    
    /*
     5
     2
     9
     6
     K
     K
     8
     7
     6
     8
     4
     6
     8
     A
     2
     2
     4
     3
     3
     J
     9
     A
     7
     10
     3
     Q
     6
     Q
     J
     9
     4
     A
     5
     4
     10
     K
     10
     8
     9
     10
     7
     Q
     A
     K
     J
     2
     5
     7
     Q
     5
     3
     J 
    ---------------------------------------------------------------------
    电脑玩家 :  5
    ME :  2
    电脑玩家 :  5   9
    ME:  2         6
    请按任意键继续. . .    
    */

• 查找替换操作：
• 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

• import java.util.*;
  public class TestSearch 
  {
      public static void main(String[] args) 
      {
          ArrayList nums = new ArrayList();
          nums.add(2);
          nums.add(-5);
          nums.add(3);
          nums.add(0);
          
          System.out.println(nums);
          //输出最大元素,将输出3
          System.out.println(Collections.max(nums));
          //输出最小元素,将输出-5
          System.out.println(Collections.min(nums));
          //将nums中的0用1来替代
          Collections.replaceAll(nums, 0, 1);
          System.out.println(nums);
          //判断-5在集合nums中出现的次数，将输出1
          System.out.println(Collections.frequency(nums, -5));
          //对nums集合排序
          Collections.sort(nums);
          System.out.println(nums);
          //只有排序后的List集合才可用二分法查询,输出3
          System.out.println(Collections.binarySearch(nums, 3));
      }
  }
  
  /*
  [2, -5, 3, 0]
  3
  -5
  [2, -5, 3, 1]
  1
  [-5, 1, 2, 3]
  3
  请按任意键继续. . .
  
  */

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

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

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