Java基礎day15

• Java基礎day15-集合2
• 1.Set集合
• • 1.1Set集合概述和特點
  • 1.2哈希值
  • 1.3HashSet集合概述和特點
  • 1.4HashSet集合保證元素唯一性源碼分析
  • 1.5常見數據結構之哈希表
  • 1.6HashSet集合存儲學生對象并遍歷
  • 1.7LinkedHashSet集合概述和特點
  • 2.Set集合排序
  • 2.1TreeSet集合概述和特點
  • 2.2自然排序Comparable的使用
  • 2.3比較器排序Comparator的使用
  • 2.4成績排序案例
  • 2.5不重復的隨機數案例
• 3.泛型
• • 3.1泛型概述和好處
  • 3.2泛型類
  • 3.3泛型方法
  • 3.4泛型接口
  • 3.5類型通配符
• 4.可變參數
• • 4.1可變參數
  • 4.2可變參數的使用

Java基礎day15-集合2

1.Set集合

1.1Set集合概述和特點

• Set集合的特點
  元素存取無序
  沒有索引、只能通過迭代器或增強for循環遍歷
  不能存儲重復元素
• Set集合的基本使用

import java.util.HashSet; import java.util.Set;public class setdemo {public static void main(String[] args) {//創建集合對象Set<String> set = new HashSet<>();//添加元素set.add("hello");set.add("world");set.add("java");//遍歷for(String s : set){System.out.println(s);}} }

1.2哈希值

• 哈希值簡介
  是JDK根據對象的地址或者字符串或者數字算出來的int類型的數值
• 如何獲取哈希值
  Object類中的public int hashCode()：返回對象的哈希碼值
• 哈希值的特點
  同一個對象多次調用hashCode()方法返回的哈希值是相同的
  默認情況下，不同對象的哈希值是不同的。而重寫hashCode()方法，可以實現讓不同對象的哈希值相同
• 獲取哈希值的代碼

1.3HashSet集合概述和特點

• HashSet集合的特點
  底層數據結構是哈希表
  對集合的迭代順序不作任何保證，也就是說不保證存儲和取出的元素順序一致
  沒有帶索引的方法，所以不能使用普通for循環遍歷
  由于是Set集合，所以是不包含重復元素的集合
• HashSet集合的基本使用

import java.util.HashSet;public class demo2 {public static void main(String[] args) {//新建集合對象HashSet<String> hs = new HashSet<>();//添加元素hs.add("hello");hs.add("world");hs.add("java");hs.add("world");//遍歷for (String s : hs){System.out.println(s);}} }

1.4HashSet集合保證元素唯一性源碼分析

• HashSet集合保證元素唯一性的原理
  1.根據對象的哈希值計算存儲位置
  如果當前位置沒有元素則直接存入
  如果當前位置有元素存在，則進入第二步
  2.當前元素的元素和已經存在的元素比較哈希值
  如果哈希值不同，則將當前元素進行存儲
  如果哈希值相同，則進入第三步
  3.通過equals()方法比較兩個元素的內容
  如果內容不相同，則將當前元素進行存儲
  如果內容相同，則不存儲當前元素
• HashSet集合保證元素唯一性的圖解
  

1.5常見數據結構之哈希表

1.6HashSet集合存儲學生對象并遍歷

• 案例需求
  創建一個存儲學生對象的集合，存儲多個學生對象，使用程序實現在控制臺遍歷該集合
  要求：學生對象的成員變量值相同，我們就認為是同一個對象
• 代碼實現

public class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;if (age != student.age) return false;return name != null ? name.equals(student.name) : student.name == null;}@Overridepublic int hashCode() {int result = name != null ? name.hashCode() : 0;result = 31 * result + age;return result;} }import java.util.HashSet;public class demo {public static void main(String[] args) {//創建Hashset集合對象HashSet<Student> hs = new HashSet<Student>();//創建學生對象Student s1 = new Student("林青霞", 30);Student s2 = new Student("張曼玉", 28);Student s3 = new Student("王祖賢", 29);Student s4 = new Student("王祖賢", 29);//把學生添加進集合hs.add(s1);hs.add(s2);hs.add(s3);hs.add(s4);//遍歷集合for (Student s : hs) {System.out.println(s.getName() + "," + s.getAge());}} }

1.7LinkedHashSet集合概述和特點

• LinkedHashSet集合特點
  哈希表和鏈表實現的Set接口，具有可預測的迭代次序
  由鏈表保證元素有序，也就是說元素的存儲和取出順序是一致的
  由哈希表保證元素唯一，也就是說沒有重復的元素
• LinkedHashSet集合基本使用

import java.util.LinkedHashSet;public class demo2 {public static void main(String[] args) {//創建集合對象LinkedHashSet<String> lhs = new LinkedHashSet<>();//添加元素lhs.add("hello");lhs.add("world");lhs.add("java");//遍歷集合for(String s : lhs){System.out.println(s);}} }

2.Set集合排序

2.1TreeSet集合概述和特點

• TreeSet集合概述
  元素有序，可以按照一定的規則進行排序，具體排序方式取決于構造方法
  ·TreeSet()：根據其元素的自然排序進行排序
  · TreeSet(Comparator comparator) ：根據指定的比較器進行排序
  沒有帶索引的方法，所以不能使用普通for循環遍歷
  由于是Set集合，所以不包含重復元素的集合
• TreeSet集合基本使用

import java.util.TreeSet;public class demo3 {public static void main(String[] args) {//創建對象TreeSet<Integer> ts = new TreeSet<>();//添加元素ts.add(10);ts.add(20);ts.add(30);ts.add(50);ts.add(20);//遍歷集合for(Integer i : ts){System.out.println(i);}} }

2.2自然排序Comparable的使用

• 案例需求
  存儲學生對象并遍歷，創建TreeSet集合使用無參構造方法
  要求：按照年齡從小到大排序，年齡相同時，按照姓名的字母順序排序
• 實現步驟
  用TreeSet集合存儲自定義對象，無參構造方法使用的是自然排序對元素進行排序的
  自然排序，就是讓元素所屬的類實現Comparable接口，重寫compareTo(T o)方法
  重寫方法時，一定要注意排序規則必須按照要求的主要條件和次要條件來寫
• 代碼實現

public class Student implements Comparable<Student> {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic int compareTo(Student s) { // return 0; // return 1;//按年齡從小到大int num = this.age - s.age;//年齡相同時，按照名字的字母排序int num2 = num == 0 ? this.name.compareTo(s.name) : num;return num2;} } //測試類 import java.util.TreeSet;public class test {public static void main(String[] args) {//創建集合對象TreeSet<Student> ts = new TreeSet<Student>();//創建學生對象Student s1 = new Student("xishi", 30);Student s2 = new Student("wangzhaojun", 32);Student s3 = new Student("diaochan", 28);Student s4 = new Student("yangyuhuan", 35);Student s5 = new Student("linqingxia", 35);Student s6 = new Student("linqingxia", 35);//把學生添加到集合ts.add(s1);ts.add(s2);ts.add(s3);ts.add(s4);ts.add(s5);ts.add(s6);//遍歷集合for (Student s : ts) {System.out.println(s.getName() + s.getAge());}} }

2.3比較器排序Comparator的使用

• 案例需求
  存儲學生對象并遍歷，創建TreeSet集合使用帶參構造方法
  要求：按照年齡從小到大排序，年齡相同時，按照姓名的字母順序排序
• 實現步驟
  用TreeSet集合存儲自定義對象，帶參構造方法使用的是比較器排序對元素進行排序的
  比較器排序，就是讓集合構造方法接收Comparator的實現類對象，重寫compare(T o1,T o2)方法
  重寫方法時，一定要注意排序規則必須按照要求的主要條件和次要條件來寫
• 代碼實現

//學生類 public class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;} } //測試類 import java.util.Comparator; import java.util.TreeSet;public class test {public static void main(String[] args) {//創建集合對象TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {@Overridepublic int compare(Student s1, Student s2) {int num = s1.getAge() - s2.getAge();int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;return num2;}});//創建學生對象Student s1 = new Student("xishi", 30);Student s2 = new Student("wangzhaojun", 32);Student s3 = new Student("diaochan", 28);Student s4 = new Student("yangyuhuan", 35);Student s5 = new Student("linqingxia", 35);Student s6 = new Student("linqingxia", 35);//把學生添加到集合ts.add(s1);ts.add(s2);ts.add(s3);ts.add(s4);ts.add(s5);ts.add(s6);//遍歷for (Student s : ts) {System.out.println(s.getName() + s.getAge());}} }

2.4成績排序案例

• 案例需求
  用TreeSet集合存儲多個學生信息(姓名，語文成績，數學成績)，并遍歷該集合
  要求：按照總分從高到低出現
• 代碼實現

public class Student {private String name;private int chinese;private int math;public Student() {}public Student(String name, int chinese, int math) {this.name = name;this.chinese = chinese;this.math = math;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getChinese() {return chinese;}public void setChinese(int chinese) {this.chinese = chinese;}public int getMath() {return math;}public void setMath(int math) {this.math = math;}public int getsum() {return this.chinese + this.math;} } //測試類 import java.util.Comparator; import java.util.TreeSet;public class test {public static void main(String[] args) {//創建集合TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {@Overridepublic int compare(Student s1, Student s2) {int num = s1.getsum() - s2.getsum();int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;int num3 = num2 == 0 ? s1.getName().compareTo(s2.getName()) : num2;return num3;}});//創建學生對象Student s1 = new Student("林青霞", 98, 99);Student s2 = new Student("張柏芝", 97, 96);Student s3 = new Student("趙云", 95, 90);Student s4 = new Student("張曼玉", 96, 94);Student s5 = new Student("劉巖", 97, 97);Student s6 = new Student("王祖賢", 97, 97);//添加ts.add(s1);ts.add(s2);ts.add(s3);ts.add(s4);ts.add(s5);ts.add(s6);//遍歷for (Student s : ts) {System.out.println(s.getName() + "," + s.getChinese() + "," + s.getMath() + "," + s.getsum());}} }

2.5不重復的隨機數案例

• 案例需求
  編寫一個程序，獲取10個1-20之間的隨機數，要求隨機數不能重復，并在控制臺輸出
• 代碼實現

import java.util.HashSet; import java.util.Random; import java.util.Set; import java.util.TreeSet;public class demo {public static void main(String[] args) {//創建集合 // Set<Integer> set = new HashSet<Integer>();Set<Integer> set = new TreeSet<Integer>();//創建隨機數Random r = new Random();//判斷集合長度是否小于10while (set.size() < 10) {int number = r.nextInt(20) + 1;set.add(number);}//遍歷集合for (Integer i : set) {System.out.println(i);}} }

3.泛型

3.1泛型概述和好處

• 泛型概述
  是JDK5中引入的特性，它提供了編譯時類型安全檢測機制，該機制允許在編譯時檢測到非法的類型
  它的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數。一提到參數，最熟悉的就是定義方
  法時有形參，然后調用此方法時傳遞實參。那么參數化類型怎么理解呢？顧名思義，就是將類型由原來的具
  體的類型參數化，然后在使用/調用時傳入具體的類型。這種參數類型可以用在類、方法和接口中，分別被稱
  為泛型類、泛型方法、泛型接口
• 泛型定義格式
  <類型>：指定一種類型的格式。這里的類型可以看成是形參
  <類型1,類型2…>：指定多種類型的格式，多種類型之間用逗號隔開。這里的類型可以看成是形參
  將來具體調用時候給定的類型可以看成是實參，并且實參的類型只能是引用數據類型
• 泛型的好處
  把運行時期的問題提前到了編譯期間
  避免了強制類型轉換

3.2泛型類

• 定義格式

修飾符 class 類名<類型> { }

• 示例代碼

//泛型類 public class Generic<T> {private T t;public T getT() {return t;}public void setT(T t) {this.t = t;} } //測試類 public class test {public static void main(String[] args) {Generic<String> g1 = new Generic<String>();g1.setT("林青霞");System.out.println(g1.getT());Generic<Integer> g2 = new Generic<Integer>();g2.setT(30);System.out.println(g2.getT());Generic<Boolean> g3 = new Generic<Boolean>();g3.setT(true);System.out.println(g3.getT());} }

3.3泛型方法

• 定義格式

修飾符 <類型> 返回值類型 方法名(類型 變量名) { }

• 示例代碼

//帶有泛型方法的類 public class Generic {public <T> void show(T t) {System.out.println(t);} } //測試類 public class test {public static void main(String[] args) {Generic g = new Generic();g.show("林青霞");g.show(30);} }

3.4泛型接口

• 定義格式

修飾符 interface 接口名<類型> { }

• 示例代碼

//泛型接口 public interface Generic<T> {void show(T t); } //泛型接口實現類 public class GenericImpl<T> implements Generic<T> {@Overridepublic void show(T t) {System.out.println(t);} } //測試類 public class test {public static void main(String[] args) {GenericImpl<String> g = new GenericImpl<String>();g.show("林青霞");GenericImpl<Integer> g1 = new GenericImpl<Integer>();g1.show(30);} }

3.5類型通配符

• 類型通配符的作用
  為了表示各種泛型List的父類，可以使用類型通配符
• 類型通配符的分類
  類型通配符：<?>
  ? ? ? List<?>：表示元素類型未知的List，它的元素可以匹配任何的類型
  ? ? ? 這種帶通配符的List僅表示它是各種泛型List的父類，并不能把元素添加到其中
• 類型通配符上限：<? extends 類型>
  ? ? ? List<? extends Number>：它表示的類型是Number或者其子類型
• 類型通配符下限：<? super 類型>
  ? ? ? List<? super Number>：它表示的類型是Number或者其父類型
• 類型通配符的基本使用

import java.util.ArrayList; import java.util.List;public class test {public static void main(String[] args) {//類型通配符：<?>List<?> list1 = new ArrayList<Object>();List<?> list2 = new ArrayList<Integer>();List<?> list3 = new ArrayList<String>();System.out.println("-------");//類型通配符上限：<? extends 類型> // List<? extends Number> list4 = new ArrayList<Object>();List<? extends Number> list5 = new ArrayList<Number>();List<? extends Number> list6 = new ArrayList<Integer>();//類型通配符下限：<? super 類型>List<? super Number> list7 = new ArrayList<Object>();List<? super Number> list8 = new ArrayList<Number>(); // List<? super Number> list9 = new ArrayList<Integer>();} }

4.可變參數

4.1可變參數

• 可變參數介紹
  可變參數又稱參數個數可變，用作方法的形參出現，那么方法參數個數就是可變的了
• 可變參數定義格式

修飾符 返回值類型 方法名(數據類型… 變量名) { }

• 可變參數的注意事項
  這里的變量其實是一個數組
  如果一個方法有多個參數，包含可變參數，可變參數要放在最后
• 可變參數的基本使用

public class test2 {public static void main(String[] args) {System.out.println(sum(10, 20));System.out.println(sum(10, 20,30,40));}public static int sum(int... a) {int sum = 0;for (int i : a) {sum += i;}return sum;} }

4.2可變參數的使用

• Arrays工具類中有一個靜態方法：
  public static List asList(T… a)：返回由指定數組支持的固定大小的列表
  返回的集合不能做增刪操作，可以做修改操作
• List接口中有一個靜態方法：
  public static List of(E… elements)：返回包含任意數量元素的不可變列表
  返回的集合不能做增刪改操作
• Set接口中有一個靜態方法：
  public static Set of(E… elements) ：返回一個包含任意數量元素的不可變集合
  在給元素的時候，不能給重復的元素
  返回的集合不能做增刪操作，沒有修改的方法
• 示例代碼

import java.util.Arrays; import java.util.List; import java.util.Set;public class test3 {public static void main(String[] args) {//public static <T> List<T> asList(T... a)：返回由指定數組支持的固定大小的列表List<String> list = Arrays.asList("hello", "world", "java"); // list.add("javaee"); //UnsupportedOperationException // list.remove("world"); //UnsupportedOperationExceptionlist.set(1,"javaee");//public static <E> List<E> of(E... elements)：返回包含任意數量元素的不可變列表List<String> list2 = List.of("hello", "world", "java", "world"); // list.add("javaee"); //UnsupportedOperationException // list.remove("world"); //UnsupportedOperationException // list.set(1,"javaee"); //UnsupportedOperationException//public static <E> Set<E> of(E... elements) ：返回一個包含任意數量元素的不可變集合Set<Object> list3 = Set.of("hello", "world", "java"); // list.add("javaee"); //UnsupportedOperationException // list.remove("world"); //UnsupportedOperationExceptionSystem.out.println(list3);} }

總結

以上是生活随笔為你收集整理的Java基础day15的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。