Java 核心类库 (一) 练习

1.　　下面代码的输出结果是什么？

　　　　　　String s1 = "abc";　　//　　表示在栈区中申请一块内存，赋给s1； s1指向常量池中的"abc"

　　　　　　String s2 = new String("abc");　　//　　表示在栈区中申请一块内存，赋给s2；在堆区中申请一块内存，内容为"abc"; s2指向堆区内存

　　　　　　s2 = s2.intern();　　

　　　　　　System.out.println(s1 == s2);

　　　　　　备注： intern() - 返回 常量池中 字符串对象 的 引用

　　　　　　　　　 也就是，去常量池中，寻找与s2内容相同的 字符串对象， 并返回　　　    

　　　　　　答：　　true.

　　　　　　　　　　s2.intern()返回了常量池中的"abc"对象

2.　　String 是线程安全的吗？

　　　　　　答：　　安全

　　　　　　　　　　因为String对象是被final修饰的，不可改变

3.　　为什么在使用HashMap的时候总是使用String类作为key的类型？

　　　　　　答：　　String类的对象不可变，故其对应的哈希码值也不改变，在放入新元素的时候，无需再次计算哈希码值，故运行效率更高

4.　　Collection 和 Collections 有什么区别？

　　　　　　答：　　Collection 是 集合，是一个顶层的接口，包含了对集合中内容进行操作的通用的方法

　　　　　　　　　　Collecrions 是 工具类，提供了大量的静态方法，实现了对集合中元素的一系列操作，如排序、搜索等

5.　　HashMap 在 Java7 和 Java8 中有哪些主要的不同之处？

　　　　　　答：　　<1>　　在结构上

　　　　　　　　　　HashMap在 Java7 中 是一个链表数组 (数组中的每一个元素都是一个链表)

　　　　　　　　　　在Java8中，如果某个链表的长度过大，或是数组的长度过大，HashMap的底层就会转化为红黑树

　　　　　　　　　　<2>　　在功能上

　　　　　　　　　　在Java 7 中, 新添元素在链表的头部

　　　　　　　　　　在Java 8 中，新添元素在链表的尾部

6.　　编程题

　　　编程统计字符串“ABCD123!@#$%ab”中大写字母、小写字母、数字、其他字符的个数并打印出来

　　　思路：(伪代码)

　　　　String str = “ABCD123!@#$%ab”;

　　　　int[] count = new int [4];

　　　　for (int i = 0; i < str.length; i++ ){

　　　　　　 if ( str.chatAt[i] >= 'A' && str.charAt[i] <= 'Z' ) {

　　　　　　　　count[0] ++;  // 统计大写字母的个数

　　　　　　}else if ( str.chatAt[i] >= 'a' && str.charAt[i] <= 'z' ) {

　　　　　　　　count[1] ++; // 统计小写字母的个数

　　　　　　}else if ( str.chatAt[i] >= '0' && str.charAt[i] <= '9' ) {

　　　　　　　　count[2] ++; // 统计数字的个数

　　　　　　}else{

　　　　　　　　count[3]++; // 统计其他字符的个数 (剩下的字符则为其他字符)

　　　　　　}　　　　

　　　　}

 代码：

// 编程统计字符串“ABCD123!@#$%ab”中
// 大写字母、小写字母、数字、其他字符的个数并打印出来

public class Question1 {
    public static void main(String[] args) {
        
        // 1. 初始化字符串 
        String str = "ABCD123!@#$%ab";
        
        // 2.初始化4个一维数组，用来记录个数
        int[] count = new int[4];
        
        // 3.遍历字符串中的每个字符
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) >= 'A' && str.charAt(i) <= 'Z') {
                count[0]++; // 统计大写字母的个数
            }else if (str.charAt(i) >= 'a' && str.charAt(i) <= 'z') {
                count[1]++; // 统计小写字母的个数
            }else if (str.charAt(i) >= '0' && str.charAt(i) <= '9') {
                count[2]++;    // 统计数字的个数
            }else {
                count[3]++; // 统计其他字符的个数 (剩下的字符则为其他字符)
            }
        }
        
        // 4.输出结果
        System.out.println("大写字母的个数为" + count[0]);
        System.out.println("小写字母的个数为" + count[1]);
        System.out.println("数字的个数为" + count[2]);
        System.out.println("其他字符的个数为" + count[3]);
        
    }
}

7.　　编程题

　　　准备一个HashMap集合，统计字符串"123,456,789,123,456"中每个数字字符串出现的次数并打印出来。

　　　如：

　　　　　　123 出现了 2 次

　　　　　　456 出现了 2 次

　　　　　　789 出现了 1 次

　　　思路：(伪代码)

　　　　　　String str = "123,456,789,123,456";

　　　　　　Array[] arr = str.spilt();

　　　　　　HashMap<key,value> map = new HashMap <key,value> ();

　　　　　　for(int i = 0; i < arr.length; i++ ){

　　　　　　　　if (map.keys does not contain arr[i] ){

　　　　　　　　　　map.addKey(arr[i]);

　　　　　　　　} 

　　　　　　　　arr[i].value ++;

　　　　　　} 

代码：

import java.util.HashMap;

// 准备一个HashMap集合，统计字符串"123,456,789,123,456"中
// 每个数字字符串出现的次数并打印出来。
public class Question2 {
    public static void main(String[] args) {
        
        // 1. 初始化字符串
        String str = "123,456,789,123,456";
        
        // 2.分割字符串，分割后的元素存入数组中
        String[] arr =  str.split(",");
        
        // 3.创建一个HashMap，统计每个数字字符串出现的次数
        HashMap<String, Integer> numberMap = new HashMap<>();
        int count;
        for(int i = 0; i < arr.length; i++) {
            if( !numberMap.containsKey(arr[i]) ) {
                numberMap.put(arr[i], 1);
            }else {
                count = numberMap.get(arr[i]) + 1;
                numberMap.put(arr[i], count);
            }  
        }
        
        // 4. 打印结果 (使用Lambda表达式遍历输出)
        numberMap.forEach((k,v) -> System.out.println(k + "的个数为：" + v));
    }
}

8.　　编程题

　　　使用集合实现斗地主游戏的部分功能，要求如下：

　　　　<1>　　首先准备54张扑克牌并打乱顺序

　　　　<2>　　由三个玩家交替摸牌，每人17张扑克牌，最后三张留作底牌

　　　　<3>　　查看三个玩家手中的扑克牌和底牌

　　　　<4>　　其中玩家手中的扑克牌需要按照大小顺序打印，规则如下：

　　　　　　　　抽中扑克牌从大到小的摆放顺序： 大王，小王，2，A，K，Q，J，10,9,8,7,6,5,4,3

　　　　思路       1.　　描述扑克牌

　　　　　　　　　　　　List 1 --> 黑 红 方 梅 （四种花色）

　　　　　　　　　　　　List 2 --> 2，A，K，Q，J，10,9,8,7,6,5,4,3 (十三种点数)

　　　　　　　　2.　　生成 54 张扑克牌

　　　　　　　　　　　　// 1. 创建一个名为 card_number的List, 用于储存每张牌所对应的编号 ( 0 ~ 53 )

　　　　　　　　　　　　List card_number = new List();

　　　　　　　　　　　　for(int i = 0; i < 54; i++) {

　　　　　　　　　　　　　　card_number.add(i);

　　　　　　　　　　　　}

　　　　　　　　　　　　// 2. 创建一个名为card_map的 Map, 用于储存扑克牌的信息 <key,value> = <编号，牌面值>

　　　　　　　　　　　　Map card_map -->　　key: 编号 ( 0 ~ 53)　

　　　　　　　　　　　　　　　　　　　　　　  value: 大王 、小王  、 List 1 X List 2 

　　　　　　　　　　　　

　　　　　　　　3.　　打乱顺序

　　　　　　　　　　　　使用Collection中的shuffle()方法打乱 牌的编号， card_number.shuffle()

　　　　　　　　4.　　将扑克牌分成三份 （每人 17 张牌）

　　　　　　　　　　　　List[] player = new List [3]; // 用于储存玩家手中的牌

　　　　　　　　　　　　List board = new List(); // 用于储存三张底牌   

　　　　　　　　　　　　for (int i = 0; i < 17*3; i++) {　

　　　　　　　　　　　　　　if ( i % 3 == 0) {

　　　　　　　　　　　　　　　　player[0].add( card_map.findValue(card_number[i]) );

　　　　　　　　　　　　　　}else if ( i % 3 == 1){

　　　　　　　　　　　　　　　　player[1].add( card_map.findValue(card_number[i]) );

　　　　　　　　　　　　　　}else{

　　　　　　　　　　　　　　　　player[2].add( card_map.findValue(card_number[i]) );

　　　　　　　　　　　　　　}　

　　　　　　　　　　　　}

　　　　　　　　　　　　最后三张留作底牌

　　　　　　　　　　　　for (int i = 0; i < 3 ; i++){

　　　　　　　　　　　　　　board.add ( card_map.findValue(card_number[ 51 + i])  ); // 51 为 倒数第三张牌的编号

　　　　　　　　　　　　}

　　　　　　　　　5.　　根据每张牌所对应的编号，给玩家手中的牌和底牌进行排序

　　　　　　　　　　　　　　for ( int i = 0; i < 2; i++ ){

　　　　　　　　　　　　　　　　player[i].sort();

　　　　　　　　　　　　　　}

　　　　　　　　　　　　　　board.sort();

　　　　　　　　　6.　　打印三个玩家手中的牌和底牌　

 代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;

/*
  使用集合实现斗地主游戏的部分功能，要求如下：

　　　　<1>　　首先准备54张扑克牌并打乱顺序

　　　　<2>　　由三个玩家交替摸牌，每人17张扑克牌，最后三张留作底牌

　　　　<3>　　查看三个玩家手中的扑克牌和底牌

　　　　<4>　　其中玩家手中的扑克牌需要按照大小顺序打印，规则如下：

　　　　　　　　抽中扑克牌从大到小的摆放顺序： 大王，小王，2，A，K，Q，J，10,9,8,7,6,5,4,3
 */

public class Question3 {

    public static void main(String[] args) {
        
        // 1.描述扑克牌:  4种花色(pattern),13种点数(figure)
        String[] pattern = {"黑桃","红桃","方块","梅花"}; 
        String[] figure = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
        
        // 2.生成54张扑克牌
        // <1> 创建一个名为 cardNumber的Array, 用于储存每张牌所对应的编号(0~53)
        ArrayList<Integer> cardNumber = new ArrayList<>();
        for(int i = 0; i < 54; i ++) {
            cardNumber.add(i);
        }
        
        // <2> 创建一个名为cardMap的HashMap,用于储存扑克牌的信息
        //     <key,value> = <编号,牌面值>
        HashMap<Integer, String> cardMap = new HashMap<>();
        
        // <3> 向cardMap集合中加入大王、小王
        cardMap.put(0, "大王");
        cardMap.put(1, "小王");
        
        // <4> 向cardMap集合中加入其它52张牌
        String cardString;
        int keyIndex = 2;
        for(int i = 0; i < 13; i ++) {
            for(int j = 0; j < 4; j++) {
                cardString = pattern[j] + figure[i]; 
                cardMap.put(keyIndex, cardString);
                keyIndex++;
            }
        }
        
        // 3.打乱54张牌的顺序
        Collections.shuffle(cardNumber);
        
        // 4.将扑克牌分成三份(每人17张牌)
        ArrayList<Integer> player1 = new ArrayList<>(); // 用于储存玩家1手中的牌的编号
        ArrayList<Integer> player2 = new ArrayList<>(); // 用于储存玩家2手中的牌的编号
        ArrayList<Integer> player3 = new ArrayList<>(); // 用于储存玩家3手中的牌的编号
        ArrayList<Integer> board = new ArrayList<>();  // 用于储存三张底牌的编号
        
        // 添加三个玩家手中的牌的编号
        for(int i = 0; i < 17 * 3; i++) {
            if(i % 3 == 0) {
                player1.add( cardNumber.get(i));
            }else if(i % 3 == 1) {
                player2.add( cardNumber.get(i));
            }else {
                player3.add( cardNumber.get(i));
            }
        }
        
        // 5.添加最后三张牌（底牌）的编号
        for(int i = 0; i < 3; i++) {
            board.add(cardNumber.get(51+i));
        }
        
        // 6.根据每张牌所对应的编号(key),给三个玩家手中的牌和底牌进行排序
        Collections.sort(player1);
        Collections.sort(player2);
        Collections.sort(player3);
        Collections.sort(board);
        
        // 7.打印玩家手中的牌和底牌
        System.out.print("玩家1： ");
        for(int i = 0; i < 17; i++) {
            System.out.print(cardMap.get(player1.get(i))+" ");
        }
        System.out.println();
        
        System.out.print("玩家2： ");
        for(int i = 0; i < 17; i++) {
            System.out.print(cardMap.get(player2.get(i))+" ");
        }    
        System.out.println();
        
        System.out.print("玩家3： ");
        for(int i = 0; i < 17; i++) {
            System.out.print(cardMap.get(player3.get(i))+" ");
        }    
        System.out.println();
        
        System.out.print("底牌：");
        for(int i = 0; i < 3; i++) {
            System.out.print(cardMap.get(board.get(i))+" ");
        }
    }
}