day17-----------集合框架
ArrayList集合的toString()方法源碼解析java
代碼：
Collection c = new ArrayList();
c.add("hello");
c.add("world");
c.add("java");
System.out.println(c);
爲何c輸出的不是地址值呢?
A:Collection c = new ArrayList();
這是多態，因此輸出c的toString()方法，實際上是輸出ArrayList的toString()
B:看ArrayList的toString()
而咱們在ArrayList裏面卻沒有發現toString()。
之後遇到這種狀況，也不要擔憂，你認爲有，它卻沒有，就應該去它父親裏面看看。
C:toString()的方法源碼
public String toString() {
Iterator<E> it = iterator(); //集合自己調用迭代器方法，獲得集合迭代器
if (! it.hasNext())
return "[]";
StringBuilder sb = new StringBuilder();
sb.append('[');
for (;;) {
E e = it.next(); //e=hello,world,java
sb.append(e == this ? "(this Collection)" : e);
if (! it.hasNext())
//[hello, world, java]
return sb.append(']').toString();
sb.append(',').append(' ');
}
}
用戶登錄註冊案例詳細分析和分包的實現
數據庫
需求：用戶登陸註冊案例。 按照以下的操做，可讓咱們更符號面向對象思想 A:有哪些類呢? B:每一個類有哪些東西呢? C:類與類之間的關係是什麼呢? 分析： A:有哪些類呢? 用戶類 測試類 B:每一個類有哪些東西呢? 用戶類： 成員變量：用戶名，密碼 構造方法：無參構造 成員方法：getXxx()/setXxx() 登陸，註冊 假如用戶類的內容比較對，未來維護起來就比較麻煩，爲了更清晰的分類，咱們就把用戶又劃分紅了兩類 用戶基本描述類 成員變量：用戶名，密碼 構造方法：無參構造 成員方法：getXxx()/setXxx() 用戶操做類 登陸，註冊 測試類： main方法。 C:類與類之間的關係是什麼呢? 在測試類中建立用戶操做類和用戶基本描述類的對象，並使用其功能。 分包： A:功能劃分 B:模塊劃分 C:先按模塊劃分，再按功能劃分 今天咱們選擇按照功能劃分： 用戶基本描述類包 cn.itcast.pojo 用戶操做接口 cn.itcast.dao 用戶操做類包 cn.itcast.dao.impl 今天是集合實現，過幾天是IO實現，再過幾天是GUI實現，就業班咱們就是數據庫實現 用戶測試類 cn.itcast.test
用戶登陸，登陸成功，玩猜數字遊戲
數據結構
package cn.itcast.pojo;
/**
* 這是用戶基本描述類
*
* @author 風清揚
* @version V1.0
*
*/
public class User {
// 用戶名
private String username;
// 密碼
private String password;
public User() {
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
package cn.itcast.dao;
import cn.itcast.pojo.User;
/**
* 這是針對用戶進行操做的接口
*
* @author 風清揚
* @version V1.0
*
*/
public interface UserDao {
/**
* 這是用戶登陸功能
*
* @param username
* 用戶名
* @param password
* 密碼
* @return 返回登陸是否成功
*/
public abstract boolean isLogin(String username, String password);
/**
* 這是用戶註冊功能
*
* @param user
* 要註冊的用戶信息
*/
public abstract void regist(User user);
}
package cn.itcast.dao.impl;
import java.util.ArrayList;
import cn.itcast.dao.UserDao;
import cn.itcast.pojo.User;
/**
* 這是用戶操做的具體實現類(集合版)
*
* @author 風清揚
* @version V1.0
*
*/
public class UserDaoImpl implements UserDao {
// 爲了讓多個方法可以使用同一個集合，就把集合定義爲成員變量
// 爲了避免讓外人看到，用private
// 爲了讓多個對象共享同一個成員變量，用static
private static ArrayList<User> array = new ArrayList<User>();
@Override
public boolean isLogin(String username, String password) {
// 遍歷集合，獲取每個用戶，並判斷該用戶的用戶名和密碼是否和傳遞過來的匹配
boolean flag = false;
for (User u : array) {
if (u.getUsername().equals(username)
&& u.getPassword().equals(password)) {
flag = true;
break;
}
}
return flag;
}
@Override
public void regist(User user) {
// 把用戶信息存儲集合
// ArrayList<User> array = new ArrayList<User>();
array.add(user);
}
}
package cn.itcast.test;
import java.util.Scanner;
import cn.itcast.dao.UserDao;
import cn.itcast.dao.impl.UserDaoImpl;
import cn.itcast.game.GuessNumber;
import cn.itcast.pojo.User;
/**
* 用戶測試類
*
* @author 風清揚
* @version V1.0
*
* 新增長了兩個小問題 A:多個對象共享同一個成員變量，用靜態
* B:循環裏面若是有switch，而且在switch裏面有break，那麼結束的不是循環，而是switch語句
*
*/
public class UserTest {
public static void main(String[] args) {
// 爲了可以回來
while (true) {
// 歡迎界面，給出選擇項
System.out.println("--------------歡迎光臨--------------");
System.out.println("1 登陸");
System.out.println("2 註冊");
System.out.println("3 退出");
System.out.println("請輸入你的選擇:");
// 鍵盤錄入選擇，根據選擇作不一樣的操做
Scanner sc = new Scanner(System.in);
// 爲了後面的錄入信息的方便，我全部的數據錄入所有用字符接收
String choiceString = sc.nextLine();
// switch語句的多個地方要使用，我就定義到外面
UserDao ud = new UserDaoImpl();
// 通過簡單的思考，我選擇了switch
switch (choiceString) {
case "1":
// 登陸界面，請輸入用戶名和密碼
System.out.println("--------------登陸界面--------------");
System.out.println("請輸入用戶名：");
String username = sc.nextLine();
System.out.println("請輸入密碼：");
String password = sc.nextLine();
// 調用登陸功能
// UserDao ud = new UserDaomImpl();
boolean flag = ud.isLogin(username, password);
if (flag) {
System.out.println("登陸成功,能夠開始玩遊戲了");
System.out.println("你玩嗎?y/n");
while (true) {
String resultString = sc.nextLine();
if (resultString.equalsIgnoreCase("y")) {
// 玩遊戲
GuessNumber.start();
System.out.println("你還玩嗎?y/n");
} else {
break;
}
}
System.out.println("謝謝使用，歡迎下次再來");
System.exit(0);
// break; //這裏寫break，結束的是switch
} else {
System.out.println("用戶名或者密碼有誤,登陸失敗");
}
break;
case "2":
// 歡迎界面，請輸入用戶名和密碼
System.out.println("--------------註冊界面--------------");
System.out.println("請輸入用戶名：");
String newUsername = sc.nextLine();
System.out.println("請輸入密碼：");
String newPassword = sc.nextLine();
// 把用戶名和密碼封裝到一個對象中
User user = new User();
user.setUsername(newUsername);
user.setPassword(newPassword);
// 調用註冊功能
// 多態
// UserDao ud = new UserDaoImpl();
// 具體類使用
// UserDaoImpl udi = new UserDaoImpl();
ud.regist(user);
System.out.println("註冊成功");
break;
case "3":
default:
System.out.println("謝謝使用，歡迎下次再來");
System.exit(0);
break;
}
}
}
}
package cn.itcast.game;
import java.util.Scanner;
/**
* 這是猜數字小遊戲
*
* @author 風清揚
* @version V1.0
*
*/
public class GuessNumber {
private GuessNumber() {
}
public static void start() {
// 產生一個隨機數
int number = (int) (Math.random() * 100) + 1;
// 定義一個統計變量
int count = 0;
while (true) {
// 鍵盤錄入一個數據
Scanner sc = new Scanner(System.in);
System.out.println("請輸入數據(1-100)：");
int guessNumber = sc.nextInt();
count++;
// 判斷
if (guessNumber > number) {
System.out.println("你猜的數據" + guessNumber + "大了");
} else if (guessNumber < number) {
System.out.println("你猜的數據" + guessNumber + "小了");
} else {
System.out.println("恭喜你，" + count + "次就猜中了");
break;
}
}
}
}
set集合
app
package cn.itcast_01;
import java.util.HashSet;
import java.util.Set;
/*
* Collection
* |--List
* 有序(存儲順序和取出順序一致),可重複
* |--Set
* 無序(存儲順序和取出順序不一致),惟一
*
* HashSet：它不保證 set 的迭代順序；特別是它不保證該順序恆久不變。
* 注意：雖然Set集合的元素無序，可是，做爲集合來講，它確定有它本身的存儲順序，
* 而你的順序剛好和它的存儲順序一致，這表明不了有序，你能夠多存儲一些數據，就能看到效果。
*/
public class SetDemo {
public static void main(String[] args) {
// 建立集合對象
Set<String> set = new HashSet<String>();
// 建立並添加元素
set.add("hello");
set.add("java");
set.add("world");
set.add("java");
set.add("world");
// 加強for
for (String s : set) {
System.out.println(s);
}
}
}
HashSet保證元素惟一性的源碼解析
dom
package cn.itcast_02;
import java.util.HashSet;
/*
* HashSet:存儲字符串並遍歷
* 問題：爲何存儲字符串的時候，字符串內容相同的只存儲了一個呢?
* 經過查看add方法的源碼，咱們知道這個方法底層依賴 兩個方法：hashCode()和equals()。
* 步驟：
* 首先比較哈希值
* 若是相同，繼續走，比較地址值或者走equals()
* 若是不一樣,就直接添加到集合中
* 按照方法的步驟來講：
* 先看hashCode()值是否相同
* 相同:繼續走equals()方法
* 返回true： 說明元素重複，就不添加
* 返回false：說明元素不重複，就添加到集合
* 不一樣：就直接把元素添加到集合
* 若是類沒有重寫這兩個方法，默認使用的Object()。通常來講不一樣相同。
* 而String類重寫了hashCode()和equals()方法，因此，它就能夠把內容相同的字符串去掉。只留下一個。
*/
public class HashSetDemo {
public static void main(String[] args) {
// 建立集合對象
HashSet<String> hs = new HashSet<String>();
// 建立並添加元素
hs.add("hello");
hs.add("world");
hs.add("java");
hs.add("world");
// 遍歷集合
for (String s : hs) {
System.out.println(s);
}
}
}
HashSet集合的add()方法的源碼ide
interface Collection {
...
}
interface Set extends Collection {
...
}
class HashSet implements Set {
private static final Object PRESENT = new Object();
private transient HashMap<E,Object> map;
public HashSet() {
map = new HashMap<>();
}
public boolean add(E e) { //e=hello,world
return map.put(e, PRESENT)==null;
}
}
class HashMap implements Map {
public V put(K key, V value) { //key=e=hello,world
//看哈希表是否爲空，若是空，就開闢空間
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
//判斷對象是否爲null
if (key == null)
return putForNullKey(value);
int hash = hash(key); //和對象的hashCode()方法相關
//在哈希表中查找hash值
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
//此次的e實際上是第一次的world
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
//走這裏實際上是沒有添加元素
}
}
modCount++;
addEntry(hash, key, value, i); //把元素添加
return null;
}
transient int hashSeed = 0;
final int hash(Object k) { //k=key=e=hello,
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode(); //這裏調用的是對象的hashCode()方法
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
}
hs.add("hello");
hs.add("world");
hs.add("java");
hs.add("world");
HashSet保證元素惟一性的代碼體現及圖解
學習
package cn.itcast_02;
/**
* @author Administrator
*
*/
public class Student {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
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;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
// @Override
// public int hashCode() {
// // return 0;
// // 由於成員變量值影響了哈希值，因此咱們把成員變量值相加便可
// // return this.name.hashCode() + this.age;
// // 看下面
// // s1:name.hashCode()=40,age=30
// // s2:name.hashCode()=20,age=50
// // 儘量的區分,咱們能夠把它們乘以一些整數
// return this.name.hashCode() + this.age * 15;
// }
//
// @Override
// public boolean equals(Object obj) {
// // System.out.println(this + "---" + obj);
// if (this == obj) {
// return true;
// }
//
// if (!(obj instanceof Student)) {
// return false;
// }
//
// Student s = (Student) obj;
// return this.name.equals(s.name) && this.age == s.age;
// }
//
// @Override
// public String toString() {
// return "Student [name=" + name + ", age=" + age + "]";
// }
}
package cn.itcast_02;
import java.util.HashSet;
/*
* 需求：存儲自定義對象，並保證元素的惟一性
* 要求：若是兩個對象的成員變量值都相同，則爲同一個元素。
*
* 目前是不符合個人要求的：由於咱們知道HashSet底層依賴的是hashCode()和equals()方法。
* 而這兩個方法咱們在學生類中沒有重寫，因此，默認使用的是Object類。
* 這個時候，他們的哈希值是不會同樣的，根本就不會繼續判斷，執行了添加操做。
*/
public class HashSetDemo2 {
public static void main(String[] args) {
// 建立集合對象
HashSet<Student> hs = new HashSet<Student>();
// 建立學生對象
Student s1 = new Student("林青霞", 27);
Student s2 = new Student("柳巖", 22);
Student s3 = new Student("王祖賢", 30);
Student s4 = new Student("林青霞", 27);
Student s5 = new Student("林青霞", 20);
Student s6 = new Student("范冰冰", 22);
// 添加元素
hs.add(s1);
hs.add(s2);
hs.add(s3);
hs.add(s4);
hs.add(s5);
hs.add(s6);
// 遍歷集合
for (Student s : hs) {
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
HashSet存儲自定義對象並遍歷
測試
package cn.itcast_03;
public class Dog {
private String name;
private int age;
private String color;
private char sex;
public Dog() {
super();
}
public Dog(String name, int age, String color, char sex) {
super();
this.name = name;
this.age = age;
this.color = color;
this.sex = sex;
}
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;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((color == null) ? 0 : color.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + sex;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Dog other = (Dog) obj;
if (age != other.age)
return false;
if (color == null) {
if (other.color != null)
return false;
} else if (!color.equals(other.color))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (sex != other.sex)
return false;
return true;
}
}
package cn.itcast_03;
import java.util.HashSet;
/*
* HashSet集合存儲自定義對象並遍歷。若是對象的成員變量值相同即爲同一個對象
*
* 注意了：
* 你使用的是HashSet集合，這個集合的底層是哈希表結構。
* 而哈希表結構底層依賴:hashCode()和equals()方法。
* 若是你認爲對象的成員變量值相同即爲同一個對象的話，你就應該重寫這兩個方法。
* 如何重寫呢?不一樣擔憂，自動生成便可。
*/
public class DogDemo {
public static void main(String[] args) {
// 建立集合對象
HashSet<Dog> hs = new HashSet<Dog>();
// 建立狗對象
Dog d1 = new Dog("秦檜", 25, "紅色", '男');
Dog d2 = new Dog("高俅", 22, "黑色", '女');
Dog d3 = new Dog("秦檜", 25, "紅色", '男');
Dog d4 = new Dog("秦檜", 20, "紅色", '女');
Dog d5 = new Dog("魏忠賢", 28, "白色", '男');
Dog d6 = new Dog("李蓮英", 23, "黃色", '女');
Dog d7 = new Dog("李蓮英", 23, "黃色", '女');
Dog d8 = new Dog("李蓮英", 23, "黃色", '男');
// 添加元素
hs.add(d1);
hs.add(d2);
hs.add(d3);
hs.add(d4);
hs.add(d5);
hs.add(d6);
hs.add(d7);
hs.add(d8);
// 遍歷
for (Dog d : hs) {
System.out.println(d.getName() + "---" + d.getAge() + "---"
+ d.getColor() + "---" + d.getSex());
}
}
}
LinkedHashSetui
package cn.itcast_04;
import java.util.LinkedHashSet;
/*
* LinkedHashSet:底層數據結構由哈希表和鏈表組成。
* 哈希表保證元素的惟一性。
* 鏈表保證元素有素。(存儲和取出是一致)
*/
public class LinkedHashSetDemo {
public static void main(String[] args) {
// 建立集合對象
LinkedHashSet<String> hs = new LinkedHashSet<String>();
// 建立並添加元素
hs.add("hello");
hs.add("world");
hs.add("java");
hs.add("world");
hs.add("java");
// 遍歷
for (String s : hs) {
System.out.println(s);
}
}
}
treeSet
this
package cn.itcast_05;
import java.util.TreeSet;
/*
* TreeSet：可以對元素按照某種規則進行排序。
* 排序有兩種方式
* A:天然排序
* B:比較器排序
*
* TreeSet集合的特色：排序和惟一
*
* 經過觀察TreeSet的add()方法，咱們知道最終要看TreeMap的put()方法。
*/
public class TreeSetDemo {
public static void main(String[] args) {
// 建立集合對象
// 天然順序進行排序
TreeSet<Integer> ts = new TreeSet<Integer>();
// 建立元素並添加
// 20,18,23,22,17,24,19,18,24
ts.add(20);
ts.add(18);
ts.add(23);
ts.add(22);
ts.add(17);
ts.add(24);
ts.add(19);
ts.add(18);
ts.add(24);
// 遍歷
for (Integer i : ts) {
System.out.println(i);
}
}
}
TreeSet的保證元素排序的源碼解析
interface Collection {...}
interface Set extends Collection {...}
interface NavigableMap {
}
class TreeMap implements NavigableMap {
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) {
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
if (cpr != null) {
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
else {
if (key == null)
throw new NullPointerException();
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
Entry<K,V> e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
}
class TreeSet implements Set {
private transient NavigableMap<E,Object> m;
public TreeSet() {
this(new TreeMap<E,Object>());
}
public boolean add(E e) {
return m.put(e, PRESENT)==null;
}
}
真正的比較是依賴於元素的compareTo()方法，而這個方法是定義在 Comparable裏面的。
因此，你要想重寫該方法，就必須是先 Comparable接口。這個接口表示的就是天然排序。
TreeSet存儲元素天然排序和惟一的圖解
TreeSet存儲自定義對象並遍歷練習
package cn.itcast_05;
/*
* 若是一個類的元素要想可以進行天然排序，就必須實現天然排序接口
*/
public class Student implements Comparable<Student> {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
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;
}
@Override
public int compareTo(Student s) {
// return 0;
// return 1;
// return -1;
// 這裏返回什麼，其實應該根據個人排序規則來作
// 按照年齡排序,主要條件
int num = this.age - s.age;
// 次要條件
// 年齡相同的時候，還得去看姓名是否也相同
// 若是年齡和姓名都相同，纔是同一個元素
int num2 = num == 0 ? this.name.compareTo(s.name) : num;
return num2;
}
}
package cn.itcast_05;
import java.util.TreeSet;
/*
* TreeSet存儲自定義對象並保證排序和惟一。
*
* A:你沒有告訴咱們怎麼排序
* 天然排序，按照年齡從小到大排序
* B:元素什麼狀況算惟一你也沒告訴我
* 成員變量值都相同即爲同一個元素
*/
public class TreeSetDemo2 {
public static void main(String[] args) {
// 建立集合對象
TreeSet<Student> ts = new TreeSet<Student>();
// 建立元素
Student s1 = new Student("linqingxia", 27);
Student s2 = new Student("zhangguorong", 29);
Student s3 = new Student("wanglihong", 23);
Student s4 = new Student("linqingxia", 27);
Student s5 = new Student("liushishi", 22);
Student s6 = new Student("wuqilong", 40);
Student s7 = new Student("fengqingy", 22);
// 添加元素
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
ts.add(s6);
ts.add(s7);
// 遍歷
for (Student s : ts) {
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
TreeSet保證元素惟一性和比較器排序的原理及代碼實現：
package cn.itcast_07;
public class Student {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
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;
}
}
package cn.itcast_07;
import java.util.Comparator;
public class MyComparator implements Comparator<Student> {
@Override
public int compare(Student s1, Student s2) {
// int num = this.name.length() - s.name.length();
// this -- s1
// s -- s2
// 姓名長度
int num = s1.getName().length() - s2.getName().length();
// 姓名內容
int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
// 年齡
int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
return num3;
}
}
package cn.itcast_07;
import java.util.Comparator;
import java.util.TreeSet;
/*
* 需求：請按照姓名的長度排序
*
* TreeSet集合保證元素排序和惟一性的原理
* 惟一性：是根據比較的返回是不是0來決定。
* 排序：
* A:天然排序(元素具有比較性)
* 讓元素所屬的類實現天然排序接口 Comparable
* B:比較器排序(集合具有比較性)
* 讓集合的構造方法接收一個比較器接口的子類對象 Comparator
*/
public class TreeSetDemo {
public static void main(String[] args) {
// 建立集合對象
// TreeSet<Student> ts = new TreeSet<Student>(); //天然排序
// public TreeSet(Comparator comparator) //比較器排序
// TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());
// 若是一個方法的參數是接口，那麼真正要的是接口的實現類的對象
// 而匿名內部類就能夠實現這個東西
TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
// 姓名長度
int num = s1.getName().length() - s2.getName().length();
// 姓名內容
int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
: num;
// 年齡
int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
return num3;
}
});
// 建立元素
Student s1 = new Student("linqingxia", 27);
Student s2 = new Student("zhangguorong", 29);
Student s3 = new Student("wanglihong", 23);
Student s4 = new Student("linqingxia", 27);
Student s5 = new Student("liushishi", 22);
Student s6 = new Student("wuqilong", 40);
Student s7 = new Student("fengqingy", 22);
Student s8 = new Student("linqingxia", 29);
// 添加元素
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
ts.add(s6);
ts.add(s7);
ts.add(s8);
// 遍歷
for (Student s : ts) {
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
package cn.itcast_08;
import java.util.HashSet;
import java.util.Random;
/*
* 編寫一個程序，獲取10個1至20的隨機數，要求隨機數不能重複。
*
* 分析：
* A:建立隨機數對象
* B:建立一個HashSet集合
* C:判斷集合的長度是否是小於10
* 是：就建立一個隨機數添加
* 否：不搭理它
* D:遍歷HashSet集合
*/
public class HashSetDemo {
public static void main(String[] args) {
// 建立隨機數對象
Random r = new Random();
// 建立一個Set集合
HashSet<Integer> ts = new HashSet<Integer>();
// 判斷集合的長度是否是小於10
while (ts.size() < 10) {
int num = r.nextInt(20) + 1;
ts.add(num);
}
// 遍歷Set集合
for (Integer i : ts) {
System.out.println(i);
}
}
}
鍵盤錄入學生信息按照總分排序後輸出在控制檯案例
package cn.itcast_08;
public class Student {
// 姓名
private String name;
// 語文成績
private int chinese;
// 數學成績
private int math;
// 英語成績
private int english;
public Student(String name, int chinese, int math, int english) {
super();
this.name = name;
this.chinese = chinese;
this.math = math;
this.english = english;
}
public Student() {
super();
}
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 getEnglish() {
return english;
}
public void setEnglish(int english) {
this.english = english;
}
public int getSum() {
return this.chinese + this.math + this.english;
}
}
package cn.itcast_08;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
/*
* 鍵盤錄入5個學生信息(姓名,語文成績,數學成績,英語成績),按照總分從高到低輸出到控制檯
*
* 分析：
* A:定義學生類
* B:建立一個TreeSet集合
* C:總分從高到底如何實現呢?
* D:鍵盤錄入5個學生信息
* E:遍歷TreeSet集合
*/
public class TreeSetDemo {
public static void main(String[] args) {
// 建立一個TreeSet集合
TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
// 總分從高到低
int num = s2.getSum() - s1.getSum();
// 總分相同的不必定語文相同
int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
// 總分相同的不必定數序相同
int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
// 總分相同的不必定英語相同
int num4 = num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3;
// 姓名還不必定相同呢
int num5 = num4 == 0 ? s1.getName().compareTo(s2.getName())
: num4;
return num5;
}
});
System.out.println("學生信息錄入開始");
// 鍵盤錄入5個學生信息
for (int x = 1; x <= 5; x++) {
Scanner sc = new Scanner(System.in);
System.out.println("請輸入第" + x + "個學生的姓名:");
String name = sc.nextLine();
System.out.println("請輸入第" + x + "個學生的語文成績:");
String chineseString = sc.nextLine();
System.out.println("請輸入第" + x + "個學生的數學成績:");
String mathString = sc.nextLine();
System.out.println("請輸入第" + x + "個學生的英語成績:");
String englishString = sc.nextLine();
// 把數據封裝到學生對象中
Student s = new Student();
s.setName(name);
s.setChinese(Integer.parseInt(chineseString));
s.setMath(Integer.parseInt(mathString));
s.setEnglish(Integer.parseInt(englishString));
// 把學生對象添加到集合
ts.add(s);
}
System.out.println("學生信息錄入完畢");
System.out.println("學習信息從高到低排序以下：");
System.out.println("姓名\t語文成績\t數學成績\t英語成績");
// 遍歷集合
for (Student s : ts) {
System.out.println(s.getName() + "\t" + s.getChinese() + "\t"
+ s.getMath() + "\t" + s.getEnglish());
}
}
}
相關文章
- 1. day17<集合框架+>
- 2. day17 集合框架 LinkedHashSet TreeSet Map 泛型
- 3. 【JAVA集合框架】Java集合框架
- 4. Java集合—集合框架
- 5. 集合_java集合框架
- 6. 集合框架
- 7. 框架——集合
- 8. 框架集合
- 9. Java集合框架
- 10. Java 集合框架
- 更多相關文章...
- • Scala Set(集合) - Scala教程
- • C# 集合（Collection） - C#教程
- • ☆技術問答集錦（13）Java Instrument原理
- • 適用於PHP初學者的學習線路和建議
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. eclipse設置粘貼字符串自動轉義
- 2. android客戶端學習-啓動模擬器異常Emulator: failed to initialize HAX: Invalid argument
- 3. android.view.InflateException: class com.jpardogo.listbuddies.lib.views.ListBuddiesLayout問題
- 4. MYSQL8.0數據庫恢復 MYSQL8.0ibd數據恢復 MYSQL8.0恢復數據庫
- 5. 你本是一個肉體，是什麼驅使你前行【1】
- 6. 2018.04.30
- 7. 2018.04.30
- 8. 你本是一個肉體，是什麼驅使你前行【3】
- 9. 你本是一個肉體，是什麼驅使你前行【2】
- 10. 【資訊】LocalBitcoins達到每週交易比特幣的7年低點
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. day17<集合框架+>
- 2. day17 集合框架 LinkedHashSet TreeSet Map 泛型
- 3. 【JAVA集合框架】Java集合框架
- 4. Java集合—集合框架
- 5. 集合_java集合框架
- 6. 集合框架
- 7. 框架——集合
- 8. 框架集合
- 9. Java集合框架
- 10. Java 集合框架