JAVA語言基礎-面向對象（集合框架02Set）
Set集合,無索引,不能夠重複,無序(存取不一致)
java
package com.heima.set;
import java.util.HashSet;
import com.heiam.bean.Person;
public class Demo1_HashSet {
/**
* @param args
* Set集合,無索引,不能夠重複,無序(存取不一致)
*/
public static void main(String[] args) {
//demo1();
HashSet<Person> hs = new HashSet<>();
hs.add(new Person("張三", 23));
hs.add(new Person("張三", 23));
hs.add(new Person("李四", 24));
hs.add(new Person("李四", 24));
hs.add(new Person("李四", 24));
hs.add(new Person("李四", 24));
//System.out.println(hs.size());
System.out.println(hs);
}
public static void demo1() {
HashSet<String> hs = new HashSet<>(); //建立HashSet對象
boolean b1 = hs.add("a");
boolean b2 = hs.add("a"); //當向set集合中存儲重複元素的時候返回爲false
hs.add("b");
hs.add("c");
hs.add("d");
System.out.println(hs); //HashSet的繼承體系中有重寫toString方法
System.out.println(b1);
System.out.println(b2);
for (String string : hs) { //只要能用迭代器迭代的,就可使用加強for循環遍歷
System.out.println(string);
}
}
}
LinkedHashSet
* 底層是鏈表實現的,是set集合中惟一一個能保證怎麼存就怎麼取的集合對象
* 由於是HashSet的子類,因此也是保證元素惟一的,與HashSet的原理同樣
數組
package com.heima.set;
import java.util.LinkedHashSet;
public class Demo2_LinkedHashSet {
/**
* @param args
* LinkedHashSet
* 底層是鏈表實現的,是set集合中惟一一個能保證怎麼存就怎麼取的集合對象
* 由於是HashSet的子類,因此也是保證元素惟一的,與HashSet的原理同樣
*/
public static void main(String[] args) {
LinkedHashSet<String> lhs = new LinkedHashSet<>();
lhs.add("a");
lhs.add("a");
lhs.add("a");
lhs.add("a");
lhs.add("b");
lhs.add("c");
lhs.add("d");
System.out.println(lhs);
}
}
TreeSet集合是用來對象元素進行排序的,一樣他也能夠保證元素的惟一
* 當compareTo方法返回0的時候集合中只有一個元素
* 當compareTo方法返回正數的時候集合會怎麼存就怎麼取
* 當compareTo方法返回負數的時候集合會倒序存儲
dom
package com.heima.set;
import java.util.Comparator;
import java.util.TreeSet;
import com.heiam.bean.Person;
public class Demo3_TreeSet {
/**
* @param args
* TreeSet集合是用來對象元素進行排序的,一樣他也能夠保證元素的惟一
* 當compareTo方法返回0的時候集合中只有一個元素
* 當compareTo方法返回正數的時候集合會怎麼存就怎麼取
* 當compareTo方法返回負數的時候集合會倒序存儲
*/
public static void main(String[] args) {
//demo1();
//demo2();
//demo3();
//demo4();
//需求:將字符串按照長度排序
TreeSet<String> ts = new TreeSet<>(new CompareByLen()); //Comparator c = new CompareByLen();
ts.add("aaaaaaaa");
ts.add("z");
ts.add("wc");
ts.add("nba");
ts.add("cba");
System.out.println(ts);
}
public static void demo4() {
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person("zhangsan", 23));
ts.add(new Person("lisi", 13));
ts.add(new Person("wangwu", 33));
ts.add(new Person("zhaoliu", 43));
ts.add(new Person("aaaa", 53));
System.out.println(ts);
}
public static void demo3() {
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person("李四", 13));
ts.add(new Person("張三", 23));
ts.add(new Person("王五", 43));
ts.add(new Person("趙六", 33));
System.out.println('張' + 0);
System.out.println('李' + 0);
System.out.println('王' + 0);
System.out.println('趙' + 0);
System.out.println(ts);
}
public static void demo2() {
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person("張三", 23));
ts.add(new Person("李四", 13));
ts.add(new Person("周七", 13));
ts.add(new Person("王五", 43));
ts.add(new Person("趙六", 33));
System.out.println(ts);
}
public static void demo1() {
TreeSet<Integer> ts = new TreeSet<>();
ts.add(3);
ts.add(1);
ts.add(1);
ts.add(2);
ts.add(2);
ts.add(3);
ts.add(3);
System.out.println(ts);
}
}
class CompareByLen /*extends Object*/ implements Comparator<String> {
@Override
public int compare(String s1, String s2) { //按照字符串的長度比較
int num = s1.length() - s2.length(); //長度爲主要條件
return num == 0 ? s1.compareTo(s2) : num; //內容爲次要條件
}
}
* A:案例演示
* 需求：編寫一個程序，獲取10個1至20的隨機數，要求隨機數不能重複。並把最終的隨機數輸出到控制檯。
*
* 分析:
* 1,有Random類建立隨機數對象
* 2,須要存儲10個隨機數,並且不能重複,因此咱們用HashSet集合
* 3,若是HashSet的size是小於10就能夠不斷的存儲,若是大於等於10就中止存儲
* 4,經過Random類中的nextInt(n)方法獲取1到20之間的隨機數,並將這些隨機數存儲在HashSet集合中
* 5,遍歷HashSet
ide
package com.heima.test;
import java.util.HashSet;
import java.util.Random;
public class Test1 {
/**
* * A:案例演示
* 需求：編寫一個程序，獲取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);
}
}
}
* 使用Scanner從鍵盤讀取一行輸入,去掉其中重複字符, 打印出不一樣的那些字符
* aaaabbbcccddd
*
* 分析:
* 1,建立Scanner對象
* 2,建立HashSet對象,將字符存儲,去掉重複
* 3,將字符串轉換爲字符數組,獲取每個字符存儲在HashSet集合中,自動去除重複
* 4,遍歷HashSet,打印每個字符
函數
package com.heima.test;
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);
}
}
}
需求:將集合中的重複元素去掉
*
* 分析:
* 1,建立List集合存儲若干個重複元素
* 2,單獨定義方法去除重複
* 3,打印一下List集合
ui
package com.heima.test;
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);
}
}
在一個集合中存儲了無序而且重複的字符串,定義一個方法,讓其有序(字典順序),並且還不能去除重複
*
* 分析:
* 1,定義一個List集合,並存儲重複的無序的字符串
* 2,定義方法對其排序保留重複
* 3,打印List集合
code
package com.heima.test;
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("heima");
list.add("itcast");
list.add("bbbb");
list.add("aaa");
list.add("aaa");
//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);
}
}
從鍵盤接收一個字符串, 程序對其中全部字符進行排序,例如鍵盤輸入: helloitcast程序打印:acehillostt
* 分析:
* 1,鍵盤錄入字符串,Scanner
* 2,將字符串轉換爲字符數組
* 3,定義TreeSet集合,傳入比較器對字符排序並保留重複
* 4,遍歷字符數組,將每個字符存儲在TreeSet集合中
* 5,遍歷TreeSet集合,打印每個字符對象
package com.heima.test;
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);
}
}
}
程序啓動後, 能夠從鍵盤輸入接收多個整數, 直到輸入quit時結束輸入. 把全部輸入的整數倒序排列打印.
*
* 1,建立Scanner對象,鍵盤錄入
* 2,建立TreeSet集合對象,TreeSet集合中傳入比較器
* 3,無限循環不斷接收整數,遇到quit退出,由於退出是quit,因此鍵盤錄入的時候應該都以字符串的形式錄入
* 4,判斷是quit就退出,不是將其轉換爲Integer,並添加到集合中
* 5,遍歷TreeSet集合並打印每個元素
排序
package com.heima.test;
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);
}
}
}
* A:案例演示
* 需求：鍵盤錄入5個學生信息(姓名,語文成績,數學成績,英語成績),按照總分從高到低輸出到控制檯。
*
* 分析:
* 1,定義一個學生類
* 成員變量:姓名,語文成績,數學成績,英語成績,總成績
* 成員方法:空參,有參構造,有參構造的參數分別是姓名,語文成績,數學成績,英語成績
* toString方法,在遍歷集合中的Student對象打印對象引用的時候會顯示屬性值
* 2,鍵盤錄入須要Scanner,建立鍵盤錄入對象
* 3,建立TreeSet集合對象,在TreeSet的構造函數中傳入比較器,按照總分比較
* 4,錄入五個學生,因此以集合中的學生個數爲判斷條件,若是size是小於5就進行存儲
* 5,將錄入的字符串切割,用逗號切割,會返回一個字符串數組,將字符串數組中從二個元素轉換成int數,
* 6,將轉換後的結果封裝成Student對象,將Student添加到TreeSet集合中
* 7,遍歷TreeSet集合打印每個Student對象
繼承
package com.heima.test;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
import com.heiam.bean.Student;
public class Test7 {
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);
}
}
}
相關文章
- 1. JAVA語言基礎-面向對象（集合框架：Map集合）
- 2. JAVA語言基礎-面向對象（集合框架01Collection）
- 3. JAVA語言基礎-面向對象（集合框架總結）
- 4. JAVA語言基礎-面向對象（集合框架02List、泛型）
- 5. JAVA語言基礎-面向對象（IO：File）
- 6. 面向對象（5）集合框架
- 7. C語言之面向對象基礎
- 8. 第二十五節：Java語言基礎-面向對象基礎
- 9. Java面向對象語法基礎
- 10. java基礎語法-面向對象(1)
- 更多相關文章...
- • R 語言基礎 - R 語言教程
- • PHP 面向對象 - PHP教程
- • Kotlin學習（一）基本語法
- • ☆基於Java Instrument的Agent實現
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
