java 集合框架

1、什么是java中的集合框架
理解管理其它对象的对象，java写了很多的类的接口，这些类库是用于管理一组对象的类库，我们把java中管理对象的类库叫集合框架，在java.util.* 下。
２、

java.util.Collection  集合框架的根接口，封装了管理对象的基础方法
java.util.List  是Collection子接口，扩充了一系列方法，以索引的方式管理对象，可以存放重复数据，常见的实现类：ArrayList, LinkedList, Stack, Vector
java.util.Set  是Collection子接口，只是简单的继承了Collection，以hashCode为key管理对象  不能存放重复的对象，常见的实现类：HashSet, LinkedHashSet, TreeSet
java.util.Map   key=value 的数据结构，常见的实现类：HashMap, Hashtable,LinkedHashMap,Properties,TreeMap

public class Demo01 {
	public static void main(String[] args) {
		Collection con=new ArrayList();
		con.add("hello");
		con.add("lisi");
		con.add(new Date());
		con.add(false);
		System.out.println(con.size());//返回此列表中的元素数。
		System.out.println(con.contains("lisi"));//contains(Object o)如果此列表中包含指定的元素，则返回 true。 
		System.out.println(con.isEmpty());
		Object[] re=con.toArray();//按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组
		re[0]=12;//覆盖掉前面的值
		System.out.println(Arrays.toString(re));
	}
}

结果：

4
true
false
[12, lisi, Sun Mar 31 18:03:23 CST 2019, false]

 ３、java.util.Iterator 是对 collection 进行迭代的迭代器

public class Demo02 {
	public static void main(String[] args) {
		Collection c=new ArrayList();
		c.add("lisi");
		c.add("lisi");
		c.add(0);
		c.add(new Date());
		c.add(false);
		Iterator i=c.iterator();
		while(i.hasNext()){
			System.out.println(i.next());
		}
		System.out.println(c);
	}
}

结果：

lisi
lisi
0
Sun Mar 31 18:12:29 CST 2019
false
[lisi, lisi, 0, Sun Mar 31 18:12:29 CST 2019, false]

public class Demo03 {
	public static void main(String[] args) {
		Collection con=new ArrayList();
		con.add("hello");
		con.add("lisi");
		con.add(false);
		con.add("hello");
   	   Iterator it=con.iterator();
	   while(it.hasNext())
	   {
		   System.out.println(it.next());
		    it.remove();//删掉刚刚拿出来的对象
	   }
	   System.out.println("-----------------------");
	   System.out.println(Arrays.toString(con.toArray()));
	}
}

结果如下： 

hello
lisi
false
hello
-----------------------
[]

List java.util.List是Collection的子接口，用于管理一组对象，以索引的方式管理

public class Demo01 {
	public static void main(String[] args) {
     List  list=new ArrayList();
     list.add("lisi");
     list.add("zhangsan");
     list.add(0,"lisa");//后面的序号依次后移
    
     list.set(2, "angel");//替换
     Iterator i=list.iterator();
     while(i.hasNext()){
    	 System.out.println(i.next());
     }
     System.out.println("-------------------------------");
     list.remove(2);//删除指定位置
     for(int j=0;j<list.size();j++)
     {
    	 System.out.println(list.get(j));//get(int index) 返回列表中指定位置的元素 
     }
	}
}

lisa
lisi
angel
-------------------------------
lisa
lisi

集合框架有什么用？

public class Demo02 {
	public static void main(String[] args) {
       List list=new ArrayList();
       for(int i=0;i<10;i++)
       {
       Stu st=new Stu("stu"+i,20+10%(i+1));
       list.add(st);
       }
       
       for(int i=0;i<list.size();i++)
       {
    	 System.out.println(list.get(i));
       }
	}
	
	static class Stu
	{
		String name;
		int age;
		public Stu() {} 
		public Stu(String name,int age){ 
			this.age=age;
			this.name=name;
			}
		@Override
		public String toString() {
			return name+":"+age;
		}
	}
}

stu0:20
stu1:20
stu2:21
stu3:22
stu4:20
stu5:24
stu6:23
stu7:22
stu8:21
stu9:20

ArrayList是List最常用的一个实现类，其核心就是以对象数组来管理对象的，ArrayList不适合频繁改变元素，尽量顺序操作 

public class Demo03 {
	public static void main(String[] args) {
		List list=new ArrayList();
		list.add("1");
		list.add(2);
		list.add(new Object());
		
		list.add(0,new Exception());
		for( int i=0;i<list.size();i++){
			System.out.println(list.get(i));
		}
		list.remove(1);
		list.remove(0);//remove(int index) 移除列表中指定位置的元素（可选操作）。 
        System.out.println("-------------------------------------");
		Iterator it=list.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}
}

java.lang.Exception
1
2
java.lang.Object@15db9742
-------------------------------------
2
java.lang.Object@15db9742

java.util.LinkedList也是List的实现类,LinkedList的核心是用双链表实现,可以频繁地操作数据

java.util.ArrayList　线程不安全的；

java.util.Vector　线程安全

java.util.Set是Collection的子接口，没有增加任何方法，它不允许存放重复数据，就是两个对象的hashcode值相同，equals为true

public class Demo01 {
	public static void main(String[] args) 
	{
	    Set set=new TreeSet();
	    set.add("lisa");
	    set.add("jack");
	    set.add("ella");
	    set.add("jack");
	    Iterator it=set.iterator();
	    while(it.hasNext())
	    {
	    	System.out.println(it.next());
	    }
	}
}

TreeSet实现了SotedSet，是一个有序的Set，默认是以自然序排列，放入TeeSet 中的每个元素，必须实现 java.lang.Comparable，如果是HashSet，则会按照哈希码排列

ella
jack
lisa

 

/**
 * Object中有int hashCode() ,所有类中都有hashCode
 * 以对象的关键字为关键字，通过一种算法求出的整数
 * 在没有重写hashCode()的前提下，两个对象不是同一个对象，那么hashcode就不相同
 * 相同对象指：两个对象的 hashcode 相同，并且equals为true
 * @author 0236ma
 *
 */
public class Demo02 {
 static class Stu
	    {
	    	private int age;
	    	private String name;
	    	public Stu() {}
	    	public Stu(String name,int age) {this.name=name;this.age=age;}
			@Override
			public String toString() {
				return "["+name+":"+age+"]";
			}
			public int hashCode()
			{
				return 20;
			}
			public boolean equals(Object obj)
			{
				return true;
			}
	    }
		
	public static void main(String[] args)
	{
		Stu s1=new Stu("lisa",23);
		Stu s2=new Stu("ali",24);
		Stu s3=new Stu("Jack",26);
		Stu s4=new Stu("dali",29);
		Stu s5=new Stu("lisa",23);
		
		System.out.println(s1.hashCode()+"--"+s5.hashCode());
		System.out.println(s1.equals(s5));
		System.out.println(s1==s5);
		
	    Set<Stu> set=new HashSet<Stu>();
	    set.add(s1);
	    set.add(s2);
	    set.add(s3);
	    set.add(s4);
	    set.add(s5);
	    
	    Iterator<Stu> it=set.iterator();
        while(it.hasNext())
        {
        	//Stu stu=it.next();
        	System.out.println(it.next());
        }
	}
}

结果如下：

 

20--20
true
false
[lisa:23]

将Demo02里面只重写hashCode方法

　　　　　　　　　public int　hashCode()
		{
			return this.age+name.hashCode();
		}
		
		public boolean equals(Object obj)
		{
			return this==obj;
		}　　　　

运行结果如下：

3322018--3322018
false
false
[lisa:23]
[lisa:23]
[ali:24]
[dali:29]
[Jack:26]

 

将Demo02里面的hashcode和equals方法全部重写

public int hashCode()
		{
			return this.age+name.hashCode();
		}
		
		public boolean equals(Object obj)
		{
			return this.hashCode()==obj.hashCode();
		}

运行可得结果如下：

3322018--3322018
true
false
[lisa:23]
[ali:24]
[dali:29]
[Jack:26]

 java.util.Map  是一种key:value的数据结构

public class Demo01 {
	static class Entry
	{
		Object key;
		Object value;
		public Entry(Object key,Object value) 
		{this.key=key;this.value=value;}
		@Override
		public String toString() {
			return key+":"+value;
		};
	}

	public static void main(String[] args) {
    List<Entry> list=new ArrayList<Entry>();
    list.add(new Entry("spring","春天"));
    list.add(new Entry("summer","夏天"));
    list.add(new Entry("fall","秋天"));
    
    for(Entry en:list)
    	System.out.println(en);
	}
}

spring:春天
summer:夏天
fall:秋天

Map的 key不能重复，Map的所有key也是一个Set

public class Demo02 {
	public static void main(String[] args) {
		Map map=new HashMap();
		map.put("mp3","视频");
		map.put("mp3", "音乐");
		map.put(23,new Object());
		map.put(false, "goto");
		
		//所有key的集合，
		Set  keys=map.keySet();//keySet()返回此映射中所包含的键的 Set 视图。
     
		Iterator it=keys.iterator();
		while(it.hasNext())
		{
			Object key=it.next();
			Object value=map.get(key);//get(Object key)返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 
			System.out.println(key+"::"+value);
		}
	}
}

mp3::音乐
false::goto
23::java.lang.Object@15db9742

public class Demo03 {
	public static void main(String[] args) {
		Map map=new HashMap();
		map.put("mp3","视频");
		map.put("mp3", "音乐");
		map.put(23,new Object());
		map.put(false, "goto");
		//Map中放的是一个一个的entry
		//entrySet()返回此映射中包含的映射关系的 Set视图 。返回值是Set<Map.Entry<K,V>>
		//public static interface Map.Entry<K,V>
		Set set=map.entrySet();
		for(Object o:set)
		{
			Map.Entry en=(Map.Entry)o;
			System.out.println(en.getKey()+"-->"+en.getValue());	
		}
	}
}

mp3-->音乐
false-->goto
23-->java.lang.Object@15db9742

public class Demo04 {
	public static void main(String[] args) {
     Map<String,Object> map=new HashMap<String,Object>();
     map.put("mp3", "音乐");
     map.put("exe", "可执行");
     map.put("mp4", "视频");
     
   Set<Map.Entry<String,Object>>  all=map.entrySet();
   for(Map.Entry<String,Object> en:all)
   {
	   System.out.println(en.getKey()+"---"+en.getValue());
   }
	}
}

结果无序排列 （准确来说是按照哈希算法排列）

mp4---视频
mp3---音乐
exe---可执行

public class Demo05 {
	public static void main(String[] args) {
     Map<String,Object> map=new TreeMap<String,Object>();
     map.put("mp4", "视频");
     map.put("mp3", "音乐");
     map.put("exe", "可执行");
    
   Set<Map.Entry<String,Object>>  all=map.entrySet();
   for(Map.Entry<String,Object> en:all)
   {
	   System.out.println(en.getKey()+"***"+en.getValue());
   }
	}
}

exe***可执行
mp3***音乐
mp4***视频

 Hashtable和 HashMap都是Map的实现类，只是Hashtable是线程安全的 

public class Demo06 {
	public static void main(String[] args) {
     Map<String,Object> map=new Hashtable<String,Object>();
     map.put("exe", "可执行");
     map.put("mp4", "视频");
     map.put("mp3", "音乐");
   
   Set<Map.Entry<String,Object>>  all=map.entrySet();
   for(Map.Entry<String,Object> en:all)
   {
	   System.out.println(en.getKey()+"***"+en.getValue());
   }
	}
}

mp3***音乐
exe***可执行
mp4***视频

java.util.Properties是Map的实现类，只是它的key和value都是字符串 

/**
 * java.util.Properties是Map的实现类，只是它的key和value都是字符串
 * Properties可以和外部文件作关联  
 */
public class Demo01 
{
  public static void main(String[] args) throws Exception
  {
	    Properties p=new Properties();
	    p.setProperty("mp3", "音乐");
	    p.put("mp4", "视频");
	    p.setProperty("txt", "文本");
	    //System.out表示控制台　
	    p.list(System.out);//将属性列表输出到指定的输出流。
	    p.list(new PrintStream("d:\\ttt.properties"));
   }
}

-- listing properties --
mp3=音乐
txt=文本
mp4=视频

/**
 * java.util.Collection接口  
 * java.util.Collections类  类似于java.util.Arrays
 * java.util.Arrays操作数组的工具类
 * java.util.Collections操作集合的工具类   List,Set,Map
 */
public class Demo01 {
	public static void main(String[] args) {
		List<String> list=new ArrayList<String>();
		list.add("0");
		list.add("1");
		list.add("3");
		list.add("6");
		Collections.sort(list);//对 List进行排序  要求List中元素都要实现比较器
		Collections.shuffle(list);//随机打乱
		for(String i:list)
		{
			System.out.println(i);
		}
	}

}

3
1
6
0