文章目录
1. Collection集合
Java集合类分为Collection和Map（键值对）两大类。
Collection接口:
1.1 Collection集合的通用方法
(1)几种常用方法
package javase.jingjie.Collection;
/**
* boolean add(Object elements)； 向集合中添加元素
* int size(); 获取集合中元素的个数
* void clear(); 清空集合
* boolean isEmpty(); 判断集合中是否有元素
* Object[] toArray(); 将集合转换成数组
*
**上面的几个调用结果:4
false
1
100
java.lang.Object@8efb846
Customer [name=jack,age=20]
0
true
*
* Iterator iterator(); 获取集合所依赖的迭代器对象
*
* boolean contains (Object o); 判断集合中是否包含某个元素
* boolean remove (Object o); 删除集合中某个元素
* */
import java.util.*;
public class CollectionTest01 {
public static void main(String[] args) {
//1. 创建集合
Collection c=new ArrayList();//多态，父类创建子类对象
//2.添加元素
c.add(1);//自动装箱，1变成Integer引用类型
c.add(new Integer(100));//Integer是引用数据类型
Object o=new Object();
c.add(o);//Collection集合只能单个存储元素，且只能存储引用数据类型
Customer cus=new Customer("jack",20);
c.add(cus);
//3.获取元素个数
System.out.println(c.size());//4
System.out.println(c.isEmpty());//false
//4.将集合转换成Object类型的数组
Object[] objs=c.toArray();
for(int i=0;i<objs.length;i++) {
System.out.println(objs[i]);//1,100,java.lang.Object@8efb846,Customer [name=jack,age=20]
}
//5.清空
c.clear();
System.out.println(c.size());//0 清零元素为0
System.out.println(c.isEmpty());//true, 上面清零，所以为空，正确
}
}
class Customer{
String name;
int age;
Customer(){}
Customer(String name, int age){
this.name=name;
this.age=age;
}
//重写Object中的toString方法
public String toString(){
return "Customer [name="+name+",age="+age+"]";
}
}
(2) 迭代器Iterator it =c.iterator() 遍历
package javase.jingjie.Collection;
import java.util.*;
/**
* Iterator iterator(); 获取集合所依赖的迭代器对象
* 通过迭代器中的方法完成集合的迭代（遍历）
* */
public class CollectionTest02 {
public static void main(String[] args) {
// 创建集合对象
Collection c=new LinkedList();
Collection t=new ArrayList();
//添加元素
c.add(100);//自动装箱
c.add(3.14);//自动装箱
c.add(false);//自动装箱
//迭代，遍历
//1.获取迭代器对象，所有集合依赖的迭代器都实现了java.util.Iterator接口
//多态，父类型Iterator指向子类型对象iterator
Iterator it =c.iterator();//获取迭代器，迭代器是面向接口编程，it是引用，保存了内存地址，指向堆中的“迭代器对象”.
Iterator is=t.iterator();
//java.util.LinkedList$ListItr 类是LinkeList集合所依赖的迭代器
//java.util.AbstractList$Itr 类是ArrayList集合所依赖的迭代器。
System.out.println(it); //java.util.LinkedList$ListItr@de6ced
System.out.println(is); //java.util.ArrayList$Itr@2a84aee7
//2.开始调用方法，完成遍历，迭代，while循环
//it是Iterator接口的一个引用，Iterator中有hasNext()和next()方法，去调用它遍历
/*
while(it.hasNext()) {
Object element=it.next();
System.out.println(element);//100 3.14 false
原则：调用it.next()方法之前必须要调用it.hasNext()方法;
boolean b=it.hasNext();//判断是否有更多的元素，如果有返回true
Object o=it.next();//将迭代器向下移动一位，并且取出指向的元素
}
*/
//for循环
for(Iterator ia=c.iterator();ia.hasNext();) {//Iterator ia=c.iterator();获取迭代器
Object o=ia.next();
System.out.println(o);//100 3.14 false
}
}
}
(3) contains、remove方法
package javase.jingjie.Collection;
/**
* boolean contains (Object o); 判断集合中是否包含某个元素
* boolean remove (Object o); 删除集合中某个元素
*
* 存储在集合中的元素应该去重写equals方法
* */
import java.util.*;
public class CollectionTest03 {
public static void main(String[] args) {
//创建集合
Collection c=new ArrayList();
//创建Integer类型的对象
Integer i1=new Integer(10);
//添加元素
c.add(i1);
//判断集合中是否包含i1
System.out.println(c.contains(i1));//true, 因为Collection集合中c.add(i1);添加了i1,所以包含
//创建Integer类型的对象
Integer i2=new Integer(10);
//判断集合中是否包含i2,contains方法底层调用的是equals方法，如果equals 返回 true，就是包含
System.out.println(c.contains(i2));//true，因为常量池的内存地址一样，所以底层自动重写equals方法，i1=i2;
Manager m1=new Manager(100,"Jack");
c.add(m1);
System.out.println(c.contains(m1));//true, 因为添加了m1，所以集合中包含m1;
Manager m2=new Manager(100,"Jack");
//重写equals方法之前，
//因为m1与m2都重新创建对象，内存地址不一样，所以底层equals方法不会自动重写，只能调用Object中的equals方法，所以不相等就不包含
//System.out.println(c.contains(m2)); false
System.out.println(c.contains(m2));//true
}
}
class Manager{
int no;
String name;
public Manager(int no,String name) {
this.name=name;
this.no=no;
}
//因为m1与m2内存地址不一样，所以必须手动重写equals方法，保证m1与m2的内容相等，否则会调用Object中的equals方法，出现false
//需求规定：如果编号和姓名都是相同，则表示同一个Manager
public boolean equals(Object o) {
if(this==o) return true;
//o为一个对象，instanceof表示一个类或者一个接口，当o为instanceof的对象，或者是其直接或者间接子类，或者是接口的实现类，结果result 都返回true，否则返回false。
if(o instanceof Manager) {//instanceof 左边对象是否为instanceof 右边类的实例，返回一个boolean类型值
Manager m=(Manager)o;//强制类型转换
if(m.no==this.no && m.name.equals(this.name)) {
return true;
}
}
return false;
}
}
remove方法和contains方法都需要集合的元素重写equals方法：
package javase.jingjie.Collection;
import java.util.ArrayList;
/**
* boolean remove(Object o)
* remove方法和contains方法都需要集合的元素重写equals方法，因为Object中的equals方法比较内存地址，在现实的业务逻辑中不能比较内存地址，该比较内容
* */
import java.util.*;
public class CollectionTest04 {
public static void main(String[] args) {
//创建集合对象
Collection c= new ArrayList();
Integer i1=new Integer(10);
//添加元素
c.add(i1);
//删除
Integer i2 =new Integer(10);
c.remove(i2);
System.out.println(c.size());//0
//Manager类已经在CollectionTest03中写过了，所以equals方法已经重写过了，这时m1与m2内容相同
Manager m1=new Manager(100, "jh");
c.add(m1);
Manager m2=new Manager(100, "jh");
c.remove(m2);
System.out.println(c.size());//0
}
}
迭代器的remove方法,集合自身带的remove方法
package javase.jingjie.Collection;
import java.util.*;
/**
* 深入remove方法：
* 1.迭代器的remove方法
* 2.集合自身带的remove方法
* */
public class CollectionTest05 {
public static void main(String[] args) {
Collection c= new ArrayList();
c.add(1);
c.add(10);
c.add(100);
//遍历,创建迭代器
Iterator it =c.iterator();
//循环while
while(it.hasNext()) {
it.next();
//删除
it.remove();//通过迭代器删除
}
System.out.println(c.size());//0
/*集合自身带的方法第二次删除元素时会报错
//使用集合自身所带的remove方法
Object element= it.next();
//删除
c.remove(element);
System.out.println(c.size());
*/
}
}
1.2 Collection–>List集合(ArrayList、Vector、LinkedList)
(1)有序可重复：存进去什么顺序，取出来还是什么顺序
package javase.jingjie.List;
/**
* List集合存储元素特点：
* 1.有序（List集合中存储有下标）：存进去是这样的顺序，取出来还是按照这个顺序取出
* 2.可重复
*
* 结果： 100
45
56
78
100
* */
import java.util.*;
public class ListTest01 {
public static void main(String[] args) {
//创建一个List集合
List l= new ArrayList();
//添加元素
l.add(100);
l.add(45);
l.add(56);
l.add(78);
l.add(100);
//迭代器遍历
Iterator it= l.iterator();
while(it.hasNext()) {
/*
Object o=it.next();
System.out.println(o);
*/
//可省略Object o=it.next();它自动输出Object类型
System.out.println(it.next());
}
}
}
(2)第二种遍历方式（list集合特有的遍历方式：for循环）
package javase.jingjie.List;
/***
* 深入List集合：
* 1.ArrayList集合底层是数组、数组是有下标的，所以ArrayList集合有很多自己的特性
* 2.ArrayList集合底层默认初始化容量是10，扩大后容量是原容量的1.5倍
* 3.Vector集合底层默认初始化容量也是10，扩大后的容量是原容量的2倍
*
* 如何优化ArrayList和Vector？
* 尽量减少扩容操作，因为扩容需要数组拷贝，数组拷贝很耗内存，
* 一般推荐在创建集合的时候指定初始化容量
* */
import java.util.*;
public class ListTest02 {
public static void main(String[] args) {
// 创建List集合，多态
List l=new ArrayList();//默认容量10
//也可以指定容量为50
//List l=new ArrayList(50);或者链表形式List l=new LinkedList(50)；
//添加元素
l.add(10);
l.add(120);
l.add(101);
l.add(10);
//在下标为1的位置上添加234
l.add(1,234);
//在下标为3的位置上添加24
l.add(3,24);
//取得第一个元素
System.out.println(l.get(0));
System.out.println("================");
//遍历（list集合特有的遍历方式）
for(int i=0;i<l.size();i++) {
Object element=l.get(i);
System.out.println(element);
}
System.out.println("-------------------");
//通过迭代器的遍历方式
Iterator it= l.iterator();
while(it.hasNext()) {
Object o=it.next();
System.out.println(o);
}
}
}
/*
* 结果：10
================
10
234
120
24
101
10
-------------------
10
234
120
24
101
10
* */
1.3 Collection–>Set集合(HashSet、SortedSet、TreeSet)
(1)HashSet（无序不可重复）
package javase.jingjie.Set;
/**
* Set集合：HashSet（无序不可重复）
* 1.HashSet底层实际上是一个HashMap,HashMap底层采用了哈希表数据结构；
* 2.哈希表又叫散列表，哈希表底层是一个数组，这个数组中每一个元素是一个
* 单项链表，每一个单向链表都有一个独一无二的hash值，代表数组的下标。
* 在某一个单向链表中的每一个节点上的hash值是相等的。hash值实际上是key调用hashCode方法，
* 在通过“hash function”转换成的值。
*
* 3.如何向哈希表中添加元素：
* 先调用被存储的key的hashCode方法，经过某一个算法得出hash值，如果在这个哈希表中不存在这个hash值，
* 则直接加入元素。如果该hash值已经存在，继续调用key之间的equals方法，如果
*equals方法返回false，则将该元素添加，如果equals方法返回true,则放弃添加该元素。
*
* 4.HashSet其实就是HashMap中的key部分，HashSet有什么特点，HashMap中的key应该具有相同的特点。
* */
import java.util.*;
public class SetTest01 {
public static void main(String[] args) {
//创建Set集合
Set s=new HashSet();
//无序不可重复
s.add(1);
s.add(1);
s.add(12);
s.add(121);
s.add(14);
//遍历
Iterator it=s.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
/*结果：无序不可重复
* 1
121
12
14
* */
}
存储在HashSet集合和HashMap集合key部分的元素，需要同时重写hashCode和equals方法
package javase.jingjie.Set;
/**
* 关于往Set集合中存储的元素，该元素的hashCode和equals方法
* HashMap中有一个put方法，put(key,value) key是无序不可重复的
* 结论：
* 1.存储在HashSet集合和HashMap集合key部分的元素，需要同时重写hashCode和equals方法
* 2.HashSet是HashMap的key部分，HashMap是HashSet的底层
* */
import java.util.*;
public class setTest02 {
public static void main(String[] args) {
//创建集合
Set es= new HashSet();
Employee e1=new Employee("1000","JACK");
Employee e2=new Employee("1000","JACK");
Employee e3=new Employee("2000","SOCTT");
Employee e4=new Employee("2300","SUN");
Employee e5=new Employee("1239","JIM");
Employee e6=new Employee("2345","COOK");
System.out.println(e1.hashCode());//1507423
System.out.println(e2.hashCode());//1507423
//添加元素
es.add(e1);
es.add(e2);
es.add(e3);
es.add(e4);
es.add(e5);
es.add(e6);
//查看集合中的元素
System.out.println(es.size());//5，说明调用hashCode和equals方法后，e1与e2相同，不满足Set集合（无序不可重复）
}
}
//根据现实业务逻辑得知：该公司员工编号是：1000~9999
class Employee{
//编号
String no;
//姓名
String name;
//构造器
public Employee(String no,String name) {
this.no=no;
this.name=name;
}
//重写equals方法，false添加，否则不加
//如果员工编号相同，名字相同，则是同一个对象
public boolean equals(Object o) {
if(this==o) {return true;
}
if(o instanceof Employee) {
Employee e=(Employee)o;//Object是所有类的父类，o也是父类型引用，所以强制类型赋值给子类型
if(e.no.equals(this.no)&&e.name.equals(this.name)) {
return true;
}
}
return false;
}
//重写HashCode方法，调用后不相同，则直接添加；相同再继续调用equals方法
public int hashCode() {
//以员工编号分组
return no.hashCode();
}
}
(2) SortedSet 无序不可重复，但是存进去的元素可以按照元素大小、先后顺序自动排列
package javase.jingjie.SortedSet;
/**
* java.util.Set;(父)
* --java.util.SortedSet;无序不可重复，但是存进去的元素可以按照元素大小、先后顺序自动排列
* ----java.util.TreeSet;
* */
import java.util.*;
import java.text.*;
public class Test01 {
public static void main(String[] args) throws Exception {
//创建集合
SortedSet ss= new TreeSet();
//添加元素，集合里只能放引用类型
ss.add(10);//10其实Integer引用类型，自动装箱
ss.add(12);
ss.add(3);
ss.add(120);
ss.add(15);
ss.add(5);
//迭代器遍历
Iterator it= ss.iterator();
while(it.hasNext()) {
System.out.println(it.next());//按大小顺序排列
}
//String类型
SortedSet strs=new TreeSet();
strs.add("JACK");
strs.add("SUN");
strs.add("COOK");
strs.add("KING");
//遍历
it=strs.iterator();
while(it.hasNext()) {
Object element=it.next();
System.out.println(element);//按字母对应位顺序大小排列
}
//日期类型
String t1="2008-08-08";
String t2="2012-08-08";
String t3="2010-09-08";
String t4="2008-08-09";
String t5="2009-08-08";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
Date st1=sdf.parse(t1);
Date st2=sdf.parse(t2);
Date st3=sdf.parse(t3);
Date st4=sdf.parse(t4);
Date st5=sdf.parse(t5);
//添加
SortedSet times=new TreeSet();
times.add(st1);
times.add(st2);
times.add(st3);
times.add(st4);
times.add(st5);
//遍历
it=times.iterator();
while(it.hasNext()) {
Object element=it.next();
if(element instanceof Date) {//判断element是否是Date类
Date d=(Date)element;
//format方法是 日期-->字符串
System.out.println(sdf.format(d));//按时间对应位大小先后顺序排列
}
}
}
}
/**
*结果：
3
5
10
12
15
120
COOK
JACK
KING
SUN
2008-08-08
2008-08-09
2009-08-08
2010-09-08
2012-08-08
* **/
SortedSet集合中的元素是自己写的，需重写Comparable–compareTo、Comparator–compare方法
package javase.jingjie.SortedSet;
import java.util.*;
/**
* 当SortedSet集合中的元素是自己写的，不是SUN公司写的，还能自动排序吗
* --不能自动调用Comparable--compareTo、Comparator--compare方法，需要
* 自己手动重写，保证SortedSet（无序不可重复）集合中的元素是按照从小到大的顺序排列
**/
public class Test02 {
public static void main(String[] args) {
SortedSet users=new TreeSet();
User u1=new User(15);
User u2=new User(16);
User u3=new User(12);
User u4=new User(23);
User u5=new User(4);
//添加元素
users.add(u1);
users.add(u2);
users.add(u3);
users.add(u4);
users.add(u5);
//遍历
Iterator it= users.iterator();
while(it.hasNext()) {
Object elements=it.next();
System.out.println(elements);
}
}
}
//第一种方法Comparable--compareTo
class User implements Comparable{
//String name;
int age;
User(int age){
this.age=age;
}
public String toString() {
return "User[age="+age+"]";
}
//实现java.lang.Comparable;接口中的compareTo方法
//该方法程序员负责实现，SUN提供的程序已经调用了该方法
public int compareTo(Object o) {
int age1=this.age;
int age2=((User)o).age;
return age2-age1;
}
}
/**
* 结果：User[age=23]
User[age=16]
User[age=15]
User[age=12]
User[age=4]
* */
第二种Comparator–compare
package javase.jingjie.SortedSet;
/**
* 单独编写一个比较器Comparator ，排序
* 第二种Comparator--compare
*
* 第一种方法Comparable--compareTo
* */
import java.util.*;
public class Test03 {
public static void main(String[] args) {
//创建TreeSet集合的时候提供一个比较器
SortedSet products= new TreeSet(new ProductComparator());
Product p1= new Product(3.4);
Product p2= new Product(4.0);
Product p3= new Product(3.0);
Product p4= new Product(2.4);
Product p5= new Product(5.4);
//添加元素
products.add(p1);
products.add(p2);
products.add(p3);
products.add(p4);
products.add(p5);
//遍历
Iterator it=products.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
//第二种方法
class Product{
double price;
Product(double price){
this.price=price;
}
public String toString() {
return price+"";
}
}
//单独编写一个比较器
class ProductComparator implements Comparator{
public int compare(Object o1,Object o2) {
double price1=((Product)o1).price;
double price2=((Product)o2).price;
if(price1==price2) {
return 0;
}else if(price1>price2) {
return 1;
}else {
return -2;
}
}
}
/**
*
* 结果：2.4
3.0
3.4
4.0
5.4
*/
2. Map集合
Map接口：
2.1 Map集合---->HashMap
(1) Map集合中常用的方法
package javase.jingjie.Map;
/**
* 关于Map集合中常用的方法：
* void clear(); 清空Map
* boolean isEmpty(); 判断该集合是否为空
* int size();获取Map集合中键值对的个数
*
* Object put(Object key,Object value);向集合中添加键值对，与Set集合add添加元素方式不一样
* Object get(Object key);通过key获取value
*
* boolean containsKey(Object key);判断Map集合中是否包含这样的key
* boolean containsValue(Object value);判断Map集合中是否包含这样的value
*
*Object remove(Object key);通过key删除键值对
*
*Colection values();获取Map集合中所有的value
*
*Set keySet();获取Map中所有的key
*
*Set<Map.Entry<K,V>> entrySet()； 返回此映射中包含的映射关系的Set视图。
*
*注意：存储在Map集合key部分的 元素需要同时重写hashCode+equals方法。
*
* */
import java.util.*;
public class MapTest01 {
public static void main(String[] args) {
// 1.创建Map集合
Map person =new HashMap();//HashMap的默认容量值16，加载因子0.75
//2.存储键值对(key,value)
person.put("10000","JACK");
person.put("10005","JACK");
person.put("10001","SUN");
person.put("10003","COOK");
person.put("10002","TOM");
person.put("10000","LUCY");
//3.判断键值对的个数，Map中的Key是无序不可重复的,和HashSet相同
System.out.println(person.size());//5
//4.判断集合中是否包含这样的key
System.out.println(person.containsKey("10000"));//true
//5.判断集合中是否包含这样的value
//注意：Map中如果key重复了，value采用的是覆盖,后面的key=10000覆盖前面的key=10000
System.out.println(person.containsValue("LUCY"));//true
//6.通过key获取value
String k="10002";
Object v=person.get(k);
System.out.println(v);//TOM
//7.通过key删除键值对
person.remove("10002");
System.out.println(person.size());//4
//8.获取所有的value,按照 key的大小顺序排列,key重复,后面的覆盖前面key
Collection values=person.values();
Iterator it=values.iterator();
while(it.hasNext()) {
System.out.println(it.next());//LUCY SUN COOK JACK
}
//9.获取所有的key，以下程序演示如何遍历Map集合
Set keys=person.keySet();
Iterator it2=keys.iterator();
while(it2.hasNext()) {
Object id=it2.next();
Object name=person.get(id);
System.out.println(id+"-->"+name);//10000-->LUCY 10001-->SUN 10003-->COOK 10005-->JACK
}
//10.Set entrySet()； 返回此映射中包含的映射关系的Set视图。
//将Map转换成Set集合
Set en=person.entrySet();
Iterator it3=en.iterator();
while(it3.hasNext()) {
Object o=it3.next();
System.out.println(o);//10000=LUCY 10001=SUN 10003=COOK 10005=JACK
}
}
}
2.2 Map集合—>Hashtable底层Properties
package javase.jingjie.Map;
/**
* Hashtable默认初始化容量11，加载因子0.75
* Hashtable底层Properties
*
* java.util.Properties;也是由key和value组成，但是key和value都是字符串类型
* 结果：I'm a teacher
周杰伦
唐嫣
邓超
* **/
import java.util.*;
public class MapTest02 {
public static void main(String[] args) {
// 1.创建属性对象
Properties p=new Properties();
//2.存
p.setProperty("drive", "I'm a teacher");
p.setProperty("username", "胡歌");
//注意key不能重复，否则后面的value覆盖
p.setProperty("username", "周杰伦");
p.setProperty("Customer", "唐嫣");
p.setProperty("star", "邓超");
//3.取，通过key获取value
String v1=p.getProperty("drive");
String v2=p.getProperty("username");
String v3=p.getProperty("Customer");
String v4=p.getProperty("star");
System.out.println(v1);//I'm a teacher
System.out.println(v2);//周杰伦
System.out.println(v3);//唐嫣
System.out.println(v4);//邓超
}
}
2.3 Map集合—>SortedMap、TreeMap
无序不可重复，但是存进去的元素可以按照大小顺序排列;
(非SUN公司)key部分元素需要手动重写，1.实现Comparable接口；2.单独写一个比较器
package javase.jingjie.Map;
/**
* SortedMap中的key特点（与SortedSet一样）：无序不可重复，但是存进去的元素可以按照大小顺序排列
* 如果想自动排序（非SUN公司的）：key部分的元素需要手动重写，1.实现Comparable接口；2.单独写一个比较器
* SortedMap底层是TreeMap
* 结果：Product[name=苹果,price=5.0]-->5.0kg
Product[name=香蕉,price=3.0]-->3.0kg
Product[name=火龙果,price=2.0]-->2.0kg
Product[name=西瓜,price=1.0]-->8.0kg
**/
import java.util.*;
public class MapTest03 {
public static void main(String[] args) {
// Map,key存储Product,value存储重量
SortedMap products=new TreeMap();//多态，SortedMap底层是TreeMap
//准备对象
Product p1= new Product("西瓜",1.0);
Product p2= new Product("香蕉",3.0);
Product p3= new Product("苹果",5.0);
Product p4= new Product("火龙果",2.0);
//添加
products.put(p1,8.0);//自动装箱
products.put(p2,3.0);
products.put(p3,5.0);
products.put(p4,2.0);
//遍历
Set keys=products.keySet();
Iterator it=keys.iterator();
while(it.hasNext()) {
Object k=it.next();
Object v=products.get(k);
System.out.println(k+"-->"+v+"kg");
}
}
}
//第一种方法：实现Comparable接口
class Product implements Comparable{
String name;
double price;
public Product(String name,double price) {
this.name=name;
this.price=price;
}
public String toString() {
return "Product[name="+name+",price="+price+"]";
}
//实现compareTo方法，按照商品价格排序
public int compareTo(Object o) {
double price1=this.price;
double price2=((Product)o).price;
if(price1>price2){
return -1;
}else if(price1<price2) {
return 1;
}else {
return 0;
}
}
}
3. Collections集合工具类
与不同 java.util.Collection;集合接口
package javase.jingjie.Collections;
/**
* 关于集合工具类 java.util.Collections;类
* 与不同 java.util.Collection;集合接口
* */
import java.util.*;
public class CollectionsTest01 {
public static void main(String[] args) {
// 使用Collections集合工具类完成排序
List l= new ArrayList();
//添加元素
l.add(10);//Integer引用类型，自动装箱 Integer implement Comparable
l.add(5);
l.add(9);
l.add(14);
l.add(2);
//遍历
/*
//1.
for(int i=0;i<l.size();i++) {
System.out.println(l.get(i));//get方法获得元素
}
//2.
for(Iterator it=l.iterator();it.hasNext();) {
System.out.println(it.next());
}
*/
//3.
Iterator it1=l.iterator();
while(it1.hasNext()) {
System.out.println(it1.next());
}
System.out.println("----------------");
//排序,Collections集合类中的方法，按大小排列
//sort方法只适合List集合接口
Collections.sort(l);
it1=l.iterator();//重新多态了一下
while(it1.hasNext()) {
System.out.println(it1.next());
}
//给定Set集合
Set s= new HashSet();
s.add(12);
s.add(10);
s.add(23);
s.add(6);
s.add(8);
//对Set集合排序,会报错，因为s是Set集合，而sort只适用List集合
//Collections.sort(s);
//将Set集合转换成List集合,s是Set集合
List lists=new ArrayList(s);
Collections.sort(lists);
Iterator it2=lists.iterator();
System.out.println("==============");
while(it2.hasNext()) {
System.out.println(it2.next());
}
//创建List集合，List集合中存储Person类型，是否可以排序？
//Collections工具类可以对List集合中元素排序，但是集合中的元素必须是“可比较的”，实现Comparable接口
List ps= new ArrayList();
ps.add(new Person(12));
ps.add(new Person(7));
ps.add(new Person(10));
ps.add(new Person(8));
Collections.sort(ps);
System.out.println("++++++++++++++++");
for(int i=0;i<ps.size();i++) {
System.out.println(ps.get(i));//get方法获得元素
}
//将ArrayList集合转换成线程安全的
List myList=new ArrayList();
Collections.synchronizedList(myList);
}
}
//自定义的类型，非SUN公司的（Integer,String,Date）,需要重写Comparable接口
class Person implements Comparable{
int shu;
Person(int shu){
this.shu=shu;
}
public String toString() {
return shu+" ";
}
public int compareTo(Object o) {
//引用.shu是传递的，
int shu1=this.shu;
int shu2=((Person)o).shu;
return shu1-shu2;
}
}
