1. 程式人生 > >JavaSE(八)之集合練習一

JavaSE(八)之集合練習一

can lec set 打印 定義 hello blog 要求 sys

前面把Collection家族給學習完畢了,接下來我們通過幾個練習來鞏固前面的知識。

一、產生10個1-20之間的隨機數要求隨機數不能重復

技術分享
import java.util.HashSet;
import java.util.Random;

public class Test1 {

    /**
     * 需求:編寫一個程序,獲取10個1至20的隨機數,要求隨機數不能重復。並把最終的隨機數輸出到控制臺。
     * 
     * 分析:
     * 1,有Random類創建隨機數對象
     * 2,需要存儲10個隨機數,而且不能重復,所以我們用HashSet集合
     * 3,如果HashSet的size是小於10就可以不斷的存儲,如果大於等於10就停止存儲
     * 4,通過Random類中的nextInt(n)方法獲取1到20之間的隨機數,並將這些隨機數存儲在HashSet集合中
     * 5,遍歷HashSet
     
*/ public static void main(String[] args) { //1,有Random類創建隨機數對象 Random r = new Random(); //2,需要存儲10個隨機數,而且不能重復,所以我們用HashSet集合 HashSet<Integer> hs = new HashSet<>(); //3,如果HashSet的size是小於10就可以不斷的存儲,如果大於等於10就停止存儲 while(hs.size() < 10) {
//4,通過Random類中的nextInt(n)方法獲取1到20之間的隨機數,並將這些隨機數存儲在HashSet集合中 hs.add(r.nextInt(20) + 1); } // 5,遍歷HashSet for (Integer integer : hs) { System.out.println(integer); } } }
Test1

二、使用Scanner從鍵盤讀取一行輸入,去掉其中重復字符, 打印出不同的那些字符

技術分享
import java.util.HashSet;
import java.util.Scanner;

public class Test2 { /** * * 使用Scanner從鍵盤讀取一行輸入,去掉其中重復字符, 打印出不同的那些字符 * aaaabbbcccddd * * 分析: * 1,創建Scanner對象 * 2,創建HashSet對象,將字符存儲,去掉重復 * 3,將字符串轉換為字符數組,獲取每一個字符存儲在HashSet集合中,自動去除重復 * 4,遍歷HashSet,打印每一個字符 */ public static void main(String[] args) { //1,創建Scanner對象 Scanner sc = new Scanner(System.in); System.out.println("請輸入一行字符串:"); //2,創建HashSet對象,將字符存儲,去掉重復 HashSet<Character> hs = new HashSet<>(); //3,將字符串轉換為字符數組,獲取每一個字符存儲在HashSet集合中,自動去除重復 String line = sc.nextLine(); char[] arr = line.toCharArray(); for (char c : arr) { //遍歷字符數組 hs.add(c); } //4,遍歷HashSet,打印每一個字符 for(Character ch : hs) { System.out.print(ch); } } }
Test2

三、在List集合中去除重復元素

技術分享
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;

public class Test3 {

    /**
     *  需求:將集合中的重復元素去掉
     *  
     *  分析:
     *  1,創建List集合存儲若幹個重復元素
     *  2,單獨定義方法去除重復
     *  3,打印一下List集合
     */
    public static void main(String[] args) {
        //1,創建List集合存儲若幹個重復元素
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("c");
        list.add("c");
        list.add("c");
        
        //2,單獨定義方法去除重復
        getSingle(list);
        
        //3,打印一下List集合
        System.out.println(list);
    }
    /*
     * 分析
     * 去除List集合中的重復元素
     * 1,創建一個LinkedHashSet集合
     * 2,將List集合中所有的元素添加到LinkedHashSet集合
     * 3,將list集合中的元素清除
     * 4,將LinkedHashSet集合中的元素添加回List集合中
     */
    public static void getSingle(List<String> list) {
        //1,創建一個LinkedHashSet集合
        LinkedHashSet<String> lhs = new LinkedHashSet<>();
        //2,將List集合中所有的元素添加到LinkedHashSet集合
        lhs.addAll(list);
        //3,將list集合中的元素清除
        list.clear();
        //4,將LinkedHashSet集合中的元素添加回List集合中
        list.addAll(lhs);
    }

}
Test3

四、 在一個集合中存儲了無序並且重復的字符串,定義一個方法,讓其有序(字典順序),而且還不能去除重復

   在這裏我們需要使用List,因為TreeSet存取重復時會存不進去。但是我們可以重寫裏面的compareTo方法讓它不等於0(當返回值為0的時候,存不進去)。

技術分享
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;

public class Test4 {

    /**
     * 在一個集合中存儲了無序並且重復的字符串,定義一個方法,讓其有序(字典順序),而且還不能去除重復
     * 
     * 分析:
     * 1,定義一個List集合,並存儲重復的無序的字符串
     * 2,定義方法對其排序保留重復
     * 3,打印List集合
     */
    public static void main(String[] args) {
        //1,定義一個List集合,並存儲重復的無序的字符串
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("aaa");
        list.add("ccc");
        list.add("ddd");
        list.add("fffffffffff");
        list.add("tengxun");
        list.add("jerry");
        list.add("bbbb");
        list.add("aaa");
        list.add("aaa");
        0
        //2,定義方法對其排序保留重復
        sort(list);
        
        //3,打印list
        System.out.println(list);
    }
    
    /*
     * 定義方法,排序並保留重復
     * 分析:
     * 1,創建TreeSet集合對象,因為String本身就具備比較功能,但是重復不會保留,所以我們用比較器
     * 2,將list集合中所有的元素添加到TrreSet集合中,對其排序,保留重復
     * 3,清空list集合
     * 4,將TreeSet集合中排好序的元素添加到list中
     */
    public static void sort(List<String> list) {
        //1,創建TreeSet集合對象,因為String本身就具備比較功能,但是重復不會保留,所以我們用比較器
        TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {

            @Override
            public int compare(String s1, String s2) {
                int num = s1.compareTo(s2);                    //比較內容為主要條件
                return num == 0 ? 1 : num;                    //保留重復
            }
        });
        //2,將list集合中所有的元素添加到TrreSet集合中,對其排序,保留重復
        ts.addAll(list);
        //3,清空list集合
        list.clear();
        //4,將TreeSet集合中排好序的元素添加到list中
        list.addAll(ts);
    }

}
Test4

五、從鍵盤接收一個字符串, 程序對其中所有字符進行排序,例如鍵盤輸入: helloworld程序打印:edhllloor

技術分享
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

public class Test5 {

    /**
     * 從鍵盤接收一個字符串, 程序對其中所有字符進行排序,例如鍵盤輸入: helloitcast程序打印:acehillostt
     * 分析:
     * 1,鍵盤錄入字符串,Scanner
     * 2,將字符串轉換為字符數組
     * 3,定義TreeSet集合,傳入比較器對字符排序並保留重復
     * 4,遍歷字符數組,將每一個字符存儲在TreeSet集合中
     * 5,遍歷TreeSet集合,打印每一個字符
     */
    public static void main(String[] args) {
        //1,鍵盤錄入字符串,Scanner
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個字符串");
        String line = sc.nextLine();
        //2,將字符串轉換為字符數組
        char[] arr = line.toCharArray();
        //3,定義TreeSet集合,傳入比較器對字符排序並保留重復
        TreeSet<Character> ts = new TreeSet<>(new Comparator<Character>() {

            @Override
            public int compare(Character c1, Character c2) {
                //int num = c1 - c2;                //自動拆箱
                int num = c1.compareTo(c2);
                return num == 0 ? 1 : num;
            }
        });
        
        //4,遍歷字符數組,將每一個字符存儲在TreeSet集合中
        for(char c : arr) {
            ts.add(c);                            //自動裝箱
        }
        
        //5,遍歷TreeSet集合,打印每一個字符
        for(Character c : ts) {
            System.out.print(c);
        }
    }

}
Test5

六、程序啟動後, 可以從鍵盤輸入接收多個整數, 直到輸入quit時結束輸入. 把所有輸入的整數倒序排列打印.

技術分享
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

public class Test6 {

    /**
     * 程序啟動後, 可以從鍵盤輸入接收多個整數, 直到輸入quit時結束輸入. 把所有輸入的整數倒序排列打印.
     * 
     * 1,創建Scanner對象,鍵盤錄入
     * 2,創建TreeSet集合對象,TreeSet集合中傳入比較器
     * 3,無限循環不斷接收整數,遇到quit退出,因為退出是quit,所以鍵盤錄入的時候應該都以字符串的形式錄入
     * 4,判斷是quit就退出,不是將其轉換為Integer,並添加到集合中
     * 5,遍歷TreeSet集合並打印每一個元素
     */
    public static void main(String[] args) {
        //1,創建Scanner對象,鍵盤錄入
        Scanner sc = new Scanner(System.in);
        //2,創建TreeSet集合對象,TreeSet集合中傳入比較器
        TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {

            @Override
            public int compare(Integer i1, Integer i2) {
                //int num = i2 - i1;                    //自動拆箱
                int num = i2.compareTo(i1);
                return num == 0 ? 1 : num;
            }
        });
        //3,無限循環不斷接收整數,遇到quit退出,因為退出是quit,所以鍵盤錄入的時候應該都以字符串的形式錄入
        while(true) {
            String line = sc.nextLine();                //將鍵盤錄入的字符串存儲在line中
            if("quit".equals(line)) {
                break;
            }
            //4,判斷是quit就退出,不是將其轉換為Integer,並添加到集合中
            Integer i = Integer.parseInt(line);
            ts.add(i);
        }
        
        // 5,遍歷TreeSet集合並打印每一個元素
        for (Integer integer : ts) {
            System.out.println(integer);
        }
    }

}
Test6

七、鍵盤錄入5個學生信息(姓名,語文成績,數學成績,英語成績),按照總分從高到低輸出到控制臺。

技術分享
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

import com.heiam.bean.Student;

public class Test7 {

    /**
     * * A:案例演示
     * 需求:鍵盤錄入5個學生信息(姓名,語文成績,數學成績,英語成績),按照總分從高到低輸出到控制臺。
     * 
     * 分析:
     * 1,定義一個學生類
     *         成員變量:姓名,語文成績,數學成績,英語成績,總成績
     *         成員方法:空參,有參構造,有參構造的參數分別是姓名,語文成績,數學成績,英語成績
     *               toString方法,在遍歷集合中的Student對象打印對象引用的時候會顯示屬性值
     * 2,鍵盤錄入需要Scanner,創建鍵盤錄入對象
     * 3,創建TreeSet集合對象,在TreeSet的構造函數中傳入比較器,按照總分比較
     * 4,錄入五個學生,所以以集合中的學生個數為判斷條件,如果size是小於5就進行存儲
     * 5,將錄入的字符串切割,用逗號切割,會返回一個字符串數組,將字符串數組中從二個元素轉換成int數,
     * 6,將轉換後的結果封裝成Student對象,將Student添加到TreeSet集合中
     * 7,遍歷TreeSet集合打印每一個Student對象
     */
    public static void main(String[] args) {
        //2,鍵盤錄入需要Scanner,創建鍵盤錄入對象
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入學生成績格式是:姓名,語文成績,數學成績,英語成績");
        //3,創建TreeSet集合對象,在TreeSet的構造函數中傳入比較器,按照總分比較
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {

            @Override
            public int compare(Student s1, Student s2) {
                int num = s2.getSum() - s1.getSum();
                return num == 0 ? 1 : num;
            }
        });
        //4,錄入五個學生,所以以集合中的學生個數為判斷條件,如果size是小於5就進行存儲
        while(ts.size() < 5) {
            //5,將錄入的字符串切割,用逗號切割,會返回一個字符串數組,將字符串數組中從二個元素轉換成int數,
            String line = sc.nextLine();
            String[] arr = line.split(",");
            int chinese = Integer.parseInt(arr[1]);
            int math = Integer.parseInt(arr[2]);
            int english = Integer.parseInt(arr[3]);
            //6,將轉換後的結果封裝成Student對象,將Student添加到TreeSet集合中
            ts.add(new Student(arr[0], chinese, math, english));
        }
        
        //7,遍歷TreeSet集合打印每一個Student對象
        System.out.println("排序後的學生信息:");
        for (Student s : ts) {
            System.out.println(s);
        }
    }

}
Test7

JavaSE(八)之集合練習一