-------android培訓java培訓期待與您交流!----------
介紹
- 出現(xiàn)的原因：面向?qū)ο笳Z言對事物的體現(xiàn)都是以對象的形式存在疏咐，為了方便對多個對象的操作辛掠，就對對象進行存儲宜鸯，集合就是存儲對象最常用的一種方式陌凳。集合就是將若干用途保檐、性質(zhì)相同或相近的"數(shù)組"組合而成一個整體伞鲫。
- 數(shù)組和集合的不同：數(shù)組可以存儲對象乙埃，但長度是固定的闸英；集合長度是可變的。數(shù)組中可以存儲基本數(shù)據(jù)類型介袜，集合只能存儲對象甫何。
- 集合的特點：集合只用于存儲對象，集合長度是可變遇伞，集合可以存粗不同類型的對象辙喂。
集合體系結(jié)構(gòu)圖
-
根據(jù)數(shù)據(jù)結(jié)構(gòu)的不同，集合可以分為以下結(jié)構(gòu)體系：
集合框架.png
Collection接口和迭代器
- 提供List、Set等數(shù)據(jù)結(jié)構(gòu)集合的最基礎共性的方法接口巍耗。
- 迭代器：集合的取出元素的方式秋麸。
實現(xiàn)為：每個數(shù)據(jù)結(jié)構(gòu)不同的集合取出方式定義在內(nèi)部，取出方式被定義成了內(nèi)部類芍锦，所以取出的方式也不一樣竹勉，但是都有共性方式：判斷和取出，可以抽取共性娄琉。而這些內(nèi)部類都可以抽取成Iterator接口特性規(guī)則次乓，對外提供iterator();方法取出元素。
package com.sergio.Collections;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* collection接口介紹接迭代器介紹
* Created by Sergio on 2015/1/16.
*/
public class CollectionDemo {
public static void main(String[] args) {
sop(-1 % 2);
}
public static void sop(Object obj) {
System.out.println(obj);
}
//集合元素交集方法
public static void CollectionRetainAllMethod() {
//創(chuàng)建一個集合容器孽水，使用Collection接口的子類ArrayList演示共性方法
Collection al1 = new ArrayList();
al1.add("hello1");
al1.add("hello2");
al1.add("hello3");
al1.add("hello4");
ArrayList al2 = new ArrayList();
al2.add("hello1");
al2.add("hello2");
al2.add("hello5");
al2.add("hello7");
al1.retainAll(al2); //取交集票腰，al中保留和al1相同的元素
al1.retainAll(al2); //刪除al中al1存在的元素
}
//collection集合基礎方法使用介紹
public static void CollectionMethod() {
//創(chuàng)建一個集合容器，使用Collection接口的子類ArrayList演示共性方法
Collection al = new ArrayList();
/**
* 添加元素
* 1. add方法的參數(shù)類型是Object女气，以便于接受任意類型對象
* 2. 集合中存儲的都是對象的引用(地址)
*/
al.add("hello1");
al.add("hello2");
al.add("hello3");
al.add("hello4");
//打印原集合
sop(al);
//獲取集合長度
sop("長度：" + al.size());
//刪除元素
al.remove("hello2");
//打印刪除后的集合
sop(al);
al.clear(); //清空集合
//判斷元素
sop("hello3" + al.contains("hello3")); //是否包含hello3元素
sop(al.isEmpty()); //是否為空
}
//獲取集合中的元素.迭代器介紹
public static void CollectionGet() {
Collection al = new ArrayList();
al.add("hello1");
al.add("hello2");
al.add("hello3");
al.add("hello4");
Iterator it = al.iterator();//獲取迭代器杏慰，用于取出集合中的元素
while (it.hasNext()) {
sop(it.next());
}
//此方法相對while循環(huán)的效果一樣。但是比while節(jié)省內(nèi)存空間炼鞠，for循環(huán)完就釋放了內(nèi)存缘滥，而while沒有。推薦使用此方法
// for(Iterator it = al.iterator(); it.hasNext();)
// {
// sop(it.next());
// }
}
}
List
- 元素是有序的谒主，元素可以重復朝扼。因為該集合體系有索引。
- 特有方法：凡是可以操作角標的方法都是該體系特有的方法霎肯。
- List特有的迭代器ListIterator：ListIterator是Iterator的子接口擎颖。在迭代器時，不可以通過集合對象的方法操作集合中的元素观游，因為會發(fā)生ConcurrentModificationException異常搂捧。因為，在迭代器時懂缕，只能用迭代器的方式操作元素允跑，可是Iterator方式有限的，只能對元素進行判斷搪柑，取出吮蛹，刪除的操作，如果想要其他的操作如添加拌屏，修改等，就需要使用其子接口ListIterator术荤。 該接口之能通過List的集合的listIterator方法獲取倚喂。因為list都帶有角標。
package com.sergio.Collections;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
* Created by Sergio on 2015/1/19.
*/
public class ListDemo1 {
public static void main(String[] args) {
List al = new ArrayList();
al.add("hello1");
al.add("hello2");
al.add("hello3");
al.add("hello4");
sop("原集合是:" + al);
al.add(1, "hello8"); //在指定位置插入元素，后面元素依次后移,容量增加1
al.remove(2); //刪除指定位置的元素
al.set(2, "hell5"); //修改指定位置的元素
al.get(3); //通過角標獲取元素
//獲取集合所有元素
for (int x = 0; x < al.size(); x++) {
System.out.println("al(" + x + " +)" + al.get(x));
}
//迭代器獲取元素
Iterator it = al.iterator();
while (it.hasNext()) {
sop("next:" + it.next());
}
sop(al.indexOf("hello3")); //通過indexOf獲取對象的位置
List sub = al.subList(1, 3); //截取列表元素端圈，包含頭焦读，不包含尾
sop(al);
listIterator();
}
/**
* List集合特有的迭代器。ListIterator是Iterator的子接口舱权。
* 在迭代器時矗晃，不可以通過集合對象的方法操作集合中的元素，因為會發(fā)生ConcurrentModificationException異常宴倍。
* 因為张症，在迭代器時，只能用迭代器的方式操作元素鸵贬，可是Iterator方式有限的俗他，只能對元素進行判斷，取出阔逼，刪除的操作兆衅，
* 如果想要其他的操作如添加，修改等嗜浮，就需要使用其子接口ListIterator羡亩。
* <p>
* 該接口之能通過List的集合的listIterator方法獲取。因為list都帶有角標.
*/
public static void listIterator() {
List al = new ArrayList();
al.add("hello1");
al.add("hello2");
al.add("hello3");
al.add("hello4");
sop(al);
//在循環(huán)中操作元素
ListIterator li = al.listIterator();
//正向獲取元素危融。
while (li.hasNext()) {
Object obj = li.next();
if (obj.equals("hello3")) {
li.add("hello6");//添加
li.set("hello4");//修改
}
}
//反向獲取元素
while (li.hasPrevious()) {
sop("pre: " + li.hasPrevious());
}
sop(al);
// //在迭代過程中畏铆，準備添加或刪除元素。在迭代器中只能使用迭代器的方法专挪，
// // 集合對象引用中只能使用集合的方法及志，集合和迭代器有兩個相同對象引用，所以修改一方時會引發(fā)安全異常寨腔。
// Iterator it = al.iterator();
// while (it.hasNext())
// {
// Object obj = it.next();
// if(obj.equals("hello2"))
// {
// it.remove(); //將hello3的引用從集合中刪除
// }
// sop("obj=" + obj);
// }
}
public static void sop(Object obj) {
System.out.println(obj);
}
}
- List常見的子類對象：
- ArrayList:底層的數(shù)據(jù)結(jié)構(gòu)使用的是數(shù)組結(jié)構(gòu)速侈。特點：查詢更改速度快，增刪稍慢迫卢。線程不同步倚搬。可變長度數(shù)組：元素初始是10的元素空間乾蛤，超過10空間每界，按原數(shù)組的50%增加空間，也就是變成15家卖，new一個新的數(shù)組眨层，將原始空間中的元素復制進來和新增加的元素添加到后面的空間中。
- LinkedList:底層使用的是鏈表數(shù)據(jù)結(jié)構(gòu)上荡。特點：查詢滿趴樱，增刪快。
- Vector:底層是數(shù)組數(shù)據(jù)結(jié)構(gòu)。特點：查詢叁征、增刪滿纳账。線程同步∞嗵郏可變長度數(shù)組：元素初始是10的元素空間疏虫，超過10空間，按原數(shù)組的50%增加空間啤呼，也就是變成15卧秘，new一個新的數(shù)組，將原始空間中的元素復制進來和新增加的元素添加到后面的空間中媳友。
- Vector：枚舉是Vector特有的取出方式斯议，枚舉和迭代器重復。枚舉的名稱和方法名稱過長醇锚，被迭代器取代了哼御。
package com.sergio.Collections;
import java.util.Enumeration;
import java.util.Vector;
/**
* Vector枚舉獲取元素
* Created by Sergio on 2015/1/19.
*/
public class VectorDemo {
public static void main(String[] args) {
Vector v = new Vector();
v.add("hello1");
v.add("hello2");
v.add("hello3");
v.add("hello4");
//和迭代器重復
Enumeration en = v.elements();
while (en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}
- LinkedList：鏈表數(shù)據(jù)結(jié)構(gòu)的，元素之間的聯(lián)系是上個元素中保存著下個元素的位置信息焊唬，每個元素是這樣聯(lián)系的恋昼，所以查詢滿，刪除塊只需要改變相鄰兩個元素之間的位置指向的信息即可赶促。
package com.sergio.Collections;
import java.util.LinkedList;
/**
* LinkedList實現(xiàn)中特有的方法介紹
* Created by Sergio on 2015/1/19.
*/
public class LinkedDemo {
public static void main(String[] args) {
LinkedList lk = new LinkedList<>();
lk.addFirst("hello1");
lk.addFirst("hello2");
lk.addFirst("hello3");
lk.addFirst("hello4");
sop(lk); //打印的順序是倒著放置元素的
//此下集中刪除獲取元素時液肌，如果集合中沒有元素，會出現(xiàn)NoSuchElementsException
//在Jdk1.6出現(xiàn)了替代方案：
//增加：offerFist(),offerLast();獲取元素不刪除(如果沒有元素會返回null)：peekFirst()鸥滨，peekLast();獲取元素并刪除(如果沒有元素會返回null)：pollFist(),pollLast().
sop(lk.removeFirst()); //獲取第一個元素并刪除
sop(lk.removeFirst()); //獲取最后一個元素并刪除
sop(lk.getFirst()); //獲取第一個元素嗦哆，不刪除元素
sop(lk.getLast()); //獲取最后一個元素，不刪除元素
//獲取集合中所有元素
while (lk.isEmpty()) {
sop(lk.getLast());
}
sop(lk.size());
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
package com.sergio.Collections;
import java.util.LinkedList;
/**
* LinkedList模擬一個堆椥鲎遥或者隊列數(shù)據(jù)結(jié)構(gòu)
* 堆棧：先進后出老速。
* 隊列：先進先出。
* Created by Sergio on 2015/1/19.
*/
public class LinkedDemo2 {
public static void main(String[] args) {
Queue q = new Queue();
q.myAdd("hello1");
q.myAdd("hello2");
q.myAdd("hello3");
q.myAdd("hello4");
//獲取所有元素
while (!q.isNull()) {
System.out.println(q.myGet());
}
Stack s = new Stack();
s.myAdd("hello1");
s.myAdd("hello2");
s.myAdd("hello3");
//獲取所有元素
while (!s.isNull()) {
System.out.println(s.myGet());
}
}
}
//隊列.根據(jù)隊列特點凸主，利用LinkedList封裝一些功能橘券。
class Queue {
private LinkedList link;
Queue() {
link = new LinkedList();
}
//在第一個位置添加元素，先進
public void myAdd(Object obj) {
link.addFirst(obj);
}
//獲取第一個進入的元素卿吐，先出
public Object myGet() {
return link.removeLast();
}
//判斷元素是否為空
public boolean isNull() {
return link.isEmpty();
}
}
//堆棧旁舰，封裝成一些功能
class Stack {
private LinkedList link;
Stack() {
link = new LinkedList();
}
//在第一個位置添加元素，先進
public void myAdd(Object obj) {
link.addFirst(obj);
}
//獲取最后一個進入的元素嗡官，后出
public Object myGet() {
return link.removeLast();
}
//判斷元素是否為空
public boolean isNull() {
return link.isEmpty();
}
}
Set
- 元素是無序(存入和取出的元素順序不一定一致)的箭窜，元素不可以重復。
- Set和Collection的功能是一致的衍腥。
- Set常見子類對象：
1.HashSet:底層的數(shù)據(jù)結(jié)構(gòu)是哈希表绽快。線程不同步芥丧。
* 保證唯一性：是通過元素的兩個方法，hashCode和equals來完成坊罢。如果元素的HashCode值相同，才會判斷equals是否為true擅耽。如果元素的HashCode值不同活孩，才會調(diào)用equals。
* 注意：對于判斷元素是否存在乖仇，以及刪除等操作憾儒，依賴方法是元素的hashCode和equals方法。
package com.sergio.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
* HashSet的添加乃沙、刪除等元素使用介紹起趾。跟Collection一致的用法。
* Created by Sergio on 2015/1/20.
*/
public class HashSetDemo {
public static void main(String[] args) {
Set hs = new HashSet<>();
//存person2的對象元素
hs.add(new Person2("hello1", 11));
hs.add(new Person2("hello3", 12));
hs.add(new Person2("hello2", 31));
hs.add(new Person2("hello1", 11));
sop(hs.contains(new Person2("hello1", 11))); //判斷新對象是否在集合中存在
hs.remove(new Person2("hello2", 12)); //刪除集合中跟新對象一樣的元素
Iterator it = hs.iterator();
while (it.hasNext()) {
Person2 p = (Person2) it.next();
sop(p.getName() + "::" + p.getAge());
}
}
public static void sop(Object obj) {
System.out.println(obj);
}
}
//存儲的對象
class Person2 {
private String name;
private int age;
Person2(String name, int age) {
this.name = name;
this.age = age;
}
//比較兩者對象的地址值
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof Person2)) {
return false;
}
Person2 p = (Person2) o;
return this.name.equals(p.name) && this.age == p.age;
}
//返回字符串的哈希值
@Override
public int hashCode() {
int result = name.hashCode();
result = 31 * result + age;
return result;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
2.TreeSet
- 可以對Set集合中的元素進行排序警儒。默認按照自然順序排序训裆。
- 排序時：當主要條件相同時，一定要判斷下次要條件蜀铲。
- 底層數(shù)據(jù)結(jié)構(gòu)是：二叉樹边琉。保證數(shù)據(jù)唯一性的依據(jù)：compareTo方法return 大于(1),等于(0),小于(-1)。
- TreeSet排序的第一種方式：讓元素自身具備比較性记劝。元素需要實現(xiàn)Comparable接口变姨，覆蓋compareTo方法，這種方式也稱為元素的自然順序厌丑，或者默認字典順序定欧。
- TreeSet的第二種排序方式：當元素自身不具備比較性，或者具備的比較性不是所需要的怒竿。這時需要讓集合自身具備比較性砍鸠。在集合初始化時，就讓其具備比較性愧口，也就是構(gòu)造函數(shù)指定比較器睦番。兩種排序都存在時，以比較器為主耍属。定義一個類托嚣，實現(xiàn)comparator接口，覆蓋compare方法厚骗。
- TreeSet使用介紹：
package com.sergio.Collections;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
/**
* TreeSet使用介紹及比較器方法介紹示启。
* Created by Sergio on 2015/1/20.
*/
public class TreeSetDemo {
public static void main(String[] args) {
Set ts = new TreeSet();
ts.add(new Student("hello1", 30));
ts.add(new Student("hello2", 30));
ts.add(new Student("hello3", 40));
Iterator it = ts.iterator();
while (it.hasNext()) {
Student stu = (Student) it.next();
System.out.println(stu.getName() + stu.getAge());
}
}
}
//此接口讓學生類具有比較性
class Student implements Comparable {
private String name;
private int age;
Student(String name, int age) {
this.name = name;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//按學生年齡大小排序
@Override
public int compareTo(Object o) {
if (!(o instanceof Student)) {
throw new RuntimeException("不是學生對象");
}
//排序判斷條件
Student stu = (Student) o;
//樹的左邊
if (this.age > stu.age) {
return 1;
}
//相等時，比較次要條件進行排序
if (this.age == stu.age) {
return this.name.compareTo(stu.name);
}
//樹的右邊
return -1;
}
}
- TreeSet第一種元素可以比較方法介紹：
package com.sergio.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
/**
* 比較器創(chuàng)建方式领舰，自定義比較器類夫嗓，實現(xiàn)comparator接口迟螺。
* Created by Sergio on 2015/1/20.
*/
public class TreeSetDemo2 {
public static void main(String[] args) {
Set ts = new TreeSet(new MyCompare());
ts.add(new Teacher("hello1", 30));
ts.add(new Teacher("hello2", 20));
ts.add(new Teacher("hello3", 50));
ts.add(new Teacher("hello2", 70));
ts.add(new Teacher("hello2", 40));
Iterator it = ts.iterator();
while (it.hasNext()) {
Teacher stu = (Teacher) it.next();
System.out.println(stu.getName() + "::" + stu.getAge());
}
}
}
//此接口讓學生類具有比較性
class Teacher implements Comparable {
private String name;
private int age;
Teacher(String name, int age) {
this.name = name;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//按年齡大小排序
@Override
public int compareTo(Object o) {
if (!(o instanceof Teacher)) {
throw new RuntimeException("不是學生對象");
}
//排序判斷條件
Teacher stu = (Teacher) o;
//樹的左邊
if (this.age > stu.age) {
return 1;
}
//相等時，比較次要條件進行排序
if (this.age == stu.age) {
return this.name.compareTo(stu.name);
}
//樹的右邊
return -1;
}
}
//自定義比較器舍咖，實現(xiàn)Comparator接口中的compare方法矩父。按姓名字幕順序自然排序
class MyCompare implements Comparator {
public int compare(Object o1, Object o2) {
Teacher s1 = (Teacher) o1;
Teacher s2 = (Teacher) o2;
int num = s1.getName().compareTo(s2.getName());
if (num == 0) {
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
//等價上一句
// if (s1.getAge() > s2.getAge())
// return 1;
// if (s1.getAge() == s2.getAge())
// return 0;
// return -1;
}
return num;
}
}
- TreeSet練習(包括內(nèi)部類使用方式介紹)
package com.sergio.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
/**
* 按字符串長度排序.比較方式微分：創(chuàng)建比較類和創(chuàng)建比較匿名函數(shù)
* Created by Sergio on 2015/1/21.
*/
public class TreeSetDemo3 {
public static void main(String[] args) {
Set ts = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
String s1 = (String) o1;
String s2 = (String) o2;
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
//主要條件比完，需要比較次要條件排霉，防止重復元素
if (num == 0) {
return s1.compareTo(s2);
}
return num;
}
});
ts.add("a");
ts.add("sff");
ts.add("sdfsfsf");
ts.add("sgdggse");
Iterator it = ts.iterator();
while (it.hasNext())
{
System.out.println(it.next());
}
}
}
//比較字符串長度
//class StringLenCompare implements Comparator {
// public int compare(Object o1, Object o2) {
// String s1 = (String) o1;
// String s2 = (String) o2;
//
// int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
// //主要條件比完窍株，需要比較次要條件，防止重復元素
// if (num == 0) {
// return s1.compareTo(s2);
// }
// return num;
// }
//}
Map
- Map框架圖：
Map結(jié)構(gòu)圖.png
Map<K,V>：K--此映射所維護的鍵的類型攻柠；V--映射值的類型球订。
Map集合存儲鍵值對，一對一對存取瑰钮，而且要保證鍵的唯一性冒滩。
Hashtable:底層是哈希表數(shù)據(jù)結(jié)構(gòu)，不可以存入null鍵null值浪谴。該集合是線程同步的开睡。效率低。
HashMap：底層是哈希表數(shù)據(jù)結(jié)構(gòu)较店，允許使用null鍵null值士八，該集合是不同步的。效率高梁呈。
TreeMap：底層是二叉樹數(shù)據(jù)結(jié)構(gòu)婚度，線程不同步」倏ǎ可以用于Map集合中鍵進行排序蝗茁。
Set集合的底層使用了Map集合功能。
package com.sergio.Collections;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
/**
* Created by Sergio on 2015/1/22.
*/
public class MapIntroduction {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
//添加元素寻咒，當存入鍵時相同時哮翘，存入的新值會覆蓋原來的值。當存入鍵時相同時毛秘，put會返回原來鍵所對應的值饭寺。
map.put("01", "yiyi");
map.put("01", "lier");
map.put("03", "lisi");
sop(map.containsKey("02")); //是否包含鍵為02的值
sop(map.remove("02")); //根據(jù)鍵刪映射值
sop(map.get("01")); //根據(jù)鍵獲取映射值.也可以通過get方法的返回值判斷一個鍵是否存在，通過返回null判斷
Collection<String> coll = map.values();
sop(coll); //獲取mao集合中所有的值
}
public static void sop(Object obj) {
System.out.println(obj);
}
}
- Map中另外兩種獲取元素的方式：
- keySet：將Map中所有的鍵存入到Set集合叫挟，而Set集合具有迭代器功能艰匙，可以通過此方式獲取所有的鍵，再根據(jù)get方法抹恳，獲取每一個鍵對應的值员凝。
- Set<Map.Entry<k,v>> entry:將Map集合中的映射關系存入到了Set集合中，而這個關系的數(shù)據(jù)類型是：Map.Entry奋献。Map.Entry的關系具體實現(xiàn)是:Entry做為Map接口的內(nèi)部接口存在健霹，其中包含getKey和getValue的方法旺上，通過這兩種方法可以獲取鍵和值。
package com.sergio.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* Map集合中的兩種獲取元素方式
* Created by Sergio on 2015/1/22.
*/
public class MapGetSet {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("01", "yiyi");
map.put("02", "lier");
map.put("03", "lisi");
//將Map集合中的映射關系取出糖埋，存入到Set集合中.這種關系類型為Map.Entry宣吱。
//再通過Map.Entry關系接口中定義的方法getKey和getValue獲取關系中的鍵和值
Set<Map.Entry<String, String>> entrySet = map.entrySet();
Iterator<Map.Entry<String, String>> it = entrySet.iterator();
while (it.hasNext())
{
Map.Entry<String, String> me = it.next();
String key = me.getKey();
String values = me.getValue();
System.out.println(key + ":"+ values);
}
//先獲取mao集合的所有鍵的Set集合，keySet
Set<String> keySet = map.keySet();
//根據(jù)Set集合阶捆，獲取迭代器
Iterator<String> it1 = keySet.iterator();
while(it1.hasNext())
{
String key = it1.next();
//結(jié)果為key的結(jié)果集
String values = map.get(key);
System.out.println("key: " + key + "values" + values);
}
}
}
練習：
package com.sergio.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* HashMap練習：公民信息有姓名凌节、年齡、住址洒试。用HashMap存儲公民信息，姓名朴上、年齡相同被視為同一個公民垒棋。公民年齡具有自然比較。
* Created by Sergio on 2015/1/22.
*/
public class HashMapTest {
public static void main(String[] args) {
Map<Citizen, String> hm = new HashMap<Citizen, String>();
hm.put(new Citizen("lisi", 23), "chengdu");
hm.put(new Citizen("haili", 34), "xian");
hm.put(new Citizen("wangi", 53), "beijing");
Set<Citizen> set = hm.keySet();
Iterator<Citizen> it = set.iterator();
while (it.hasNext()) {
Citizen ct = it.next();
String str = hm.get(ct);
System.out.println(ct + str);
}
}
}
class Citizen implements Comparable<Citizen> {
private String name;
private int age;
Citizen(String name, int age) {
this.name = name;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int compareTo(Citizen s) {
int num = new Integer(this.age).compareTo(s.getAge());
if (num == 0) {
return this.name.compareTo(s.getName());
}
return num;
}
public int hashCode() {
return name.hashCode() + age * 34;
}
public boolean equals(Object obj) {
// if (this == obj) {
// return true;
// }
if (!(obj instanceof Citizen)) {
throw new ClassCastException("輸入類型與公民類型不匹配");
}
Citizen s = (Citizen) obj;
return this.name.equals(s.getName()) && this.age == s.getAge();
}
@Override
public String toString() {
return "Citizen{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.sergio.Collections;
import java.util.*;
/**
* TreeMap練習痪宰，創(chuàng)建比較器類叼架，讓公民的名字具有比較器。
* Created by Sergio on 2015/1/23.
*/
public class TreeMapTest {
public static void main(String[] args) {
Map<Citizen, String> hc = new TreeMap<Citizen, String>(new MyCompareTo());
hc.put(new Citizen("abc", 23), "beijing");
hc.put(new Citizen("wabc", 33), "shanghai");
hc.put(new Citizen("sabc", 43), "chengdu");
Set<Map.Entry<Citizen, String>> tm = hc.entrySet();
Iterator<Map.Entry<Citizen, String>> it = tm.iterator();
while (it.hasNext()) {
Map.Entry<Citizen, String> me = it.next();
Citizen cname = me.getKey();
String add = me.getValue();
System.out.println(cname + add);
}
}
}
//自定義比較器類
class MyCompareTo implements Comparator<Citizen> {
@Override
public int compare(Citizen o1, Citizen o2) {
int num = o1.getName().compareTo(o2.getName());
if (num == 0) {
return new Integer(o1.getAge()).compareTo(o2.getAge());
}
return num;
}
}
package com.sergio.Collections;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
/**
* 集合嵌套練習
* Created by Sergio on 2015/2/11.
*/
public class CollectionInCollection {
public static void main(String[] args) {
demo();
}
//參考集合嵌套書寫
public static void demo() {
HashMap<String, List<Car>> jhqt = new HashMap<>();
List<Car> jc = new ArrayList<Car>();
List<Car> pc = new ArrayList<Car>();
jhqt.put("轎車", jc);
jhqt.put("跑車", pc);
jc.add(new Car("0111", "zhangsa"));
jc.add(new Car("023444", "lisi"));
pc.add(new Car("0234", "wangwu"));
pc.add(new Car("01234", "maliu"));
//迭代器獲取車信息
Iterator<String> it = jhqt.keySet().iterator();
while (it.hasNext()) {
String carName = it.next();
List<Car> name = jhqt.get(carName);
System.out.println(carName);
getInfo(name);
}
}
//獲取list集合中的信息
public static void getInfo(List<Car> list) {
Iterator<Car> it = list.iterator();
while (it.hasNext()) {
Car c = it.next();
System.out.println(c);
}
}
//獲取嵌套集合中車信息方式
// public static void getCarInfo(HashMap<String, String> carMap) {
// Iterator<String> it = carMap.keySet().iterator();
// while (it.hasNext()) {
// String id = it.next();
// String name = carMap.get(id);
// System.out.println(id + "::::" + name);
// }
// }
}
class Car {
private String id;
private String name;
Car(String id, String name) {
this.id = id;
this.name = name;
}
public String toString() {
return id + ":::::" + name;
}
}
Collections工具類
- 此工具類中的方法定義的都是靜態(tài)方法衣撬，共享性數(shù)據(jù)乖订，沒有提供構(gòu)造函數(shù)。
-
public static <T extends [Comparable<? super T>> void sort([List<T> list)：集合工具類中的List集合排序方法具练，<T extends [Comparable<? super T>>表示類型限定是Comparable的子類乍构，接受的類型是子類或者子類的父類。 - Collection和Collections的區(qū)別：
- Collection是集合框架的一個頂層接口扛点，定義了單列集合的共性方法哥遮，兩個重要的子接口List(對元素都有定義索引。有序陵究，元素可重復)眠饮、Set(元素不重復，無序)铜邮。
- Colections是集合框架中的一個工具類仪召，該類的方法都是靜態(tài)的，提供對list等集合進行排序松蒜，二分查找等方法扔茅，通常常用的集合都是線程不安全的，當多線程操作這些集合時牍鞠，可以使用該工具類將線程不安全的集合轉(zhuǎn)換成安全同步的咖摹。
package com.sergio.CollectionsUtils;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* 工具類使用。排序方法介紹
* Created by Sergio on 2015-02-23.
*/
public class IntroductionCollections {
public static void main(String[] args) {
sortDemo();
maxDemo();
fillDem();
reverseDemo();
}
//排序
public static void sortDemo() {
List<String> list = new ArrayList<>();
list.add("absdf");
list.add("bsdfdf");
list.add("osdf");
sop(list);
//工具類排序难述，數(shù)組實現(xiàn)的重復元素排序按索引排序
Collections.sort(list);
////工具類排序.自定義比較器
Collections.sort(list, new StrLenComparator());
sop(list);
}
//求最大值.
public static void maxDemo() {
List<String> list = new ArrayList<>();
list.add("absdf");
list.add("bsdfdf");
list.add("osdf");
list.add("zzz");
sop(list);
//按自然排序求最大值
String max2 = Collections.max(list);
//自定義比較器排序求最大值
String max = Collections.max(list, new StrLenComparator());
sop(max);
sop(max2);
}
//二分查找.集合必須是有序的
public static void binarySearchDemo() {
List<String> list = new ArrayList<>();
list.add("absdf");
list.add("bsdfdf");
list.add("osdf");
list.add("zzz");
//先進性排序
Collections.sort(list);
sop(list);
int index = Collections.binarySearch(list, "zzz");
sop("index " + index);
}
//將集合中的元素全部替換成指定元素
public static void fillDem() {
List<String> list = new ArrayList<>();
list.add("absdf");
list.add("bsdfdf");
list.add("osdf");
list.add("zzz");
sop(list);
Collections.fill(list, "ppp");
sop(list);
}
//替換指定區(qū)間的元素
public static void fillDemo2(List<String> list, int start, int end, String str) {
List<String> list1 = new ArrayList<>();
list1.add("absdf");
list1.add("bsdfdf");
list1.add("osdf");
list1.add("zzz");
List<String> subList = list.subList(start, end);
Collections.fill(subList, str);
sop(list);
}
//反轉(zhuǎn)集合元素
public static void reverseDemo() {
List<String> list = new ArrayList<>();
list.add("sdf");
list.add("sdfsdf");
list.add("weri");
Collections.reverse(list);
sop(list);
}
public static void sop(Object obj) {
System.out.println(obj);
}
}
//自定義比較器
class StrLenComparator implements Comparator<String> {
public int compare(String s1, String s2) {
if (s1.length() > s2.length()) {
return 1;
}
if (s1.length() < s2.length()) {
return -1;
}
return s1.compareTo(s2);
}
}
Arrays工具類
package com.sergio.Arrays;
import java.util.Arrays;
import java.util.List;
/**
* 數(shù)組變集合
* Created by Sergio on 2015-02-23.
*/
public class ArrayToCollection{
public static void main(String[] args) {
String[] str = {"1", "2", "5"};
/**
* 將數(shù)組變成list集合：
* 變成list集合后可以使用集合的思想和方法來操作數(shù)組中的元素萤晴。
* 注意：不可以使用集合的增刪方法吐句。因為數(shù)組的長度是固定的。
*/
List<String> list = Arrays.asList(str);
System.out.println("包含：" + list.contains("4"));
System.out.println(list);
/**
* 如果數(shù)組中的元素都是對象店读，那么變成集合時嗦枢，數(shù)組中的元素就直接轉(zhuǎn)換成集合中的元素。
* 如果數(shù)組中的元素都是基礎數(shù)據(jù)類型屯断，那么會將數(shù)組作為集合中的元素存在文虏。
*/
int[] num = {1, 2, 6};
List<int[]> li = Arrays.asList(num);
System.out.println(li);
}
}
package com.sergio.Arrays;
import java.util.ArrayList;
import java.util.Arrays;
/**
* 集合轉(zhuǎn)數(shù)組.當集合元素數(shù)限定，轉(zhuǎn)成數(shù)組不可操作增刪操作殖演，非常有用
* Created by Sergio on 2015-02-23.
*/
public class CollectionToArray {
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<>();
al.add("acb1");
al.add("abc2");
al.add("abc3");
//數(shù)組的大小為集合元素的空間大小
String[] arr = al.toArray(new String[al.size()]);
System.out.println(Arrays.toString(arr));
}
}
