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 [B@1, B@1, C@2, A@2a139a55, A@15db9742] 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无法准确访问该对象
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
-
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这个同步实现;
6. 操作集合的工具类
排序操作：
-
-
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()
