JAVA学习笔记整理六(类集框架)

原创 2016年05月31日 10:58:26

类集框架接口的具体特点




接口的继承关系



集合框架中的实现类

Collection接口

1.    此接口是单值存放的最大父类接口,可以向其中保存多个单值(单个的对象)数据,一般不直接使用,因为表示的操作意义不明确。

2.    使用了泛型的定义,在操作时必须指定具体的操作类型,以保证类集操作的安全性,避免发生ClassCastException异常

List接口

1.     ArrayList

public class ArrayListTest {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("Hello");
		list.add("Hello");
		list.add(1,"World");//在第1个位置(即第一个数据之后,以0——(size()-1)计数)
		list.add(3,"Java");//在第3个位置添加
		
		System.out.println(list);
		System.out.println("集合中有多少数据:" + list.size());
		System.out.println("集合中是否有Java:" + list.contains("Java"));//此处区分大小写
		System.out.println("得到第几位的元素" + list.get(2));
		System.out.println("Java字符串的位置:" + list.indexOf("Java"));
		
		String[] strs = list.toArray(new String[] {});// 集合转指定类型的数组
		for (Object str : strs) {
			System.out.print(str + ", ");
		}
		System.out.println();
		String[] arr = { "hello", "java", "hello", "jsp"};
		List list1 = Arrays.asList(arr);//数组转列表(大小固定,为数组大小)
		System.out.println("数组转列表:" + list1);
		
		List subList=list.subList(1, 3);//返回列表中指定的 fromIndex(包括 )和 toIndex(不包括)之间的部分视图
		System.out.println(subList);
		
		Collection coll = new ArrayList<>();
		coll.add("Hello");
		coll.add("SQL");
		list.addAll(coll);// 将coll集合中的所有元素添加至list
		System.out.println("将coll集合中的所有元素添加至list:" + list);
		System.out.println("list是否包含coll:" + list.containsAll(coll));
//		list.removeAll(coll);//从list中删除两个集合的交集
//		System.out.println("删除两个集合的交集后:" + list);//删除两个集合的交集后:[World, Java]
		list.retainAll(coll);//保留交集,其余删除
		System.out.println("保留交集,其余删除后:" + list);
		
		list.remove("Hello");//删除'Hello'
		System.out.println("删除'Hello'后:" + list);//只删除第一个
		list.clear();
		System.out.println("清空所有元素后:"  + list);
		System.out.println("集合是否为空:" + list.isEmpty());
	}
}

//[Hello, World, Hello, Java]
//集合中有多少数据:4
//集合中是否有Java:true
//得到第几位的元素Hello
//Java字符串的位置:3
//Hello, World, Hello, Java, 
//数组转列表:[hello, java, hello, jsp]
//[World, Hello]
//将coll集合中的所有元素添加至list:[Hello, World, Hello, Java, Hello, SQL]
//list是否包含coll:true
//保留交集,其余删除后:[Hello, Hello, Hello, SQL]
//删除'World'后:[Hello, Hello, SQL]
//清空所有元素后:[]
//集合是否为空:true

2.     LinkedList:

public class LinkedListDemo {
	public static void main(String[] args) {
		LinkedList ll = new LinkedList();
		ll.add("A");
		ll.add("B");
		ll.add("C");
		System.out.println("初始化列表:" + ll);
		
		ll.addFirst("X");//在链表的表头增加数据
		ll.addLast("Y");//在链表的表尾增加数据
		System.out.println("增加头和尾之后的链表:" + ll);
		
		System.out.println("element找到的表头:" + ll.element());//element()表示获取但不移除此列表的头
		System.out.println("element找完之后:" + ll);
		System.out.println("peek找到的表头:" + ll.peek());//获取但不移除此列表的头(第一个元素)
		System.out.println("peek找完之后:" + ll);
		System.out.println("poll找到的表头:" + ll.poll());//获取并移除此列表的头(第一个元素)
		System.out.println("poll找完之后:" + ll);
		
		ll.offer("g");//将指定元素添加到此列表的末尾
		System.out.println("添加指定元素之后的链表:" + ll);
		Collections.fill(ll, "x");//使用指定元素替换指定列表中的所有元素
		System.out.println("替换之后的链表:" + ll);
	}
}

//初始化列表:[A, B, C]
//增加头和尾之后的链表:[X, A, B, C, Y]
//element找到的表头:X
//element找完之后:[X, A, B, C, Y]
//peek找到的表头:X
//peek找完之后:[X, A, B, C, Y]
//poll找到的表头:X
//poll找完之后:[A, B, C, Y]
//添加指定元素之后的链表:[A, B, C, Y, g]
//替换之后的链表:[x, x, x, x, x]

3.     区别

    1)  我们可以将ArrayList看作是能够自动增长容量的数组,可以直接利用ArrayList的toArray()返回一个数组

    2)  ArrayList底层采用数组完成,而LinkedList则是以一般的双向链表(double-linked list)完成,其内每个对象除了数据本身外,还有两个引用,分别指向前一个元素和后一个元素

    3)  LinkedList在实现List接口的同时,还实现了Queue接口,采用“先进先出”的方式操作

   4) 如果我们经常在List的开始处增加元素,或者在List中进行插入和删除操作,我们应该使用LinkedList,否则的话,使用ArrayList将更加快速

Set接口

Set接口不能增加重复元素,实例无法像List接口那样可以进行双向输出。

1.     HashSet:散列的存放:不能存放重复元素,并且采用散列的存储方式,无序排列

2.     TreeSet:有序的存放:不能存放重复元素,有序排列,可以自定义类进行去重复并按照自己规定的顺序进行排序

3.     TreeSet实现了SorteSet接口(是 SorteMap 的 set 对应接口)
public class SetTest {
	public static void main(String[] args) {
		
     // hashSet
     Set hashSet = new HashSet();
		hashSet.add("A");
		hashSet.add("A");
		hashSet.add("B");
		hashSet.add("C");
		hashSet.add("C");
		hashSet.add("D");
		System.out.println("hashSet:" + hashSet);
		// hashSet:[D, A, B, C]

	// treeSet
     Set treeSet = new TreeSet();
		treeSet.add("D");
		treeSet.add("A");
		treeSet.add("C");
		treeSet.add("D");
		treeSet.add("B");
		treeSet.add("A");
		System.out.println("treeSet:" + treeSet);
		// treeSet:[A, B, C, D]
		
     // myTreeSet
		Set myTreeSet = new TreeSet();
		myTreeSet.add(new Child("张三", 18));
		myTreeSet.add(new Child("李四", 20));
		myTreeSet.add(new Child("王五", 21));
		myTreeSet.add(new Child("王五", 21));
		myTreeSet.add(new Child("张三", 19));
		myTreeSet.add(new Child("张三", 18));
		System.out.println("myTreeSet:" + myTreeSet);
		// myTreeSet:[姓名:张三==年龄:18, 姓名:张三==年龄:19,
		//姓名:李四==年龄:20, 姓名:王五==年龄:21]
     
     // SortedSet
        SortedSet sortedSet = new TreeSet();
		sortedSet.add("A");
		sortedSet.add("B");//同样不能放入重复
		sortedSet.add("B");
		sortedSet.add("C");
		sortedSet.add("A");
		sortedSet.add("D");
		sortedSet.add("E");
		System.out.println("第一个元素:" + sortedSet.first());//第一个元素:A
	    System.out.println("最后一个元素:" + sortedSet.last());//最后一个元素:E
		System.out.println("headSet元素:" + sortedSet.headSet("C"));
		//C的前面,不包括C  headSet元素:[A, B]
		System.out.println("tailSet元素:" + sortedSet.tailSet("C"));
		//C的后面,包括   CtailSet元素:[C, D, E]
		System.out.println("subSet元素:" + sortedSet.subSet("B", "D"));
		//B、D中间,包含B不包含D  subSet元素:[B, C]
	}
}

class Child implements Comparable {
    // TreeSet中为有序排列,所以对于自定义的类使用TreeSet进行存放时,
    //对于一个对象必须指定好排序规则,需要实现Commparable接口才能正常使用
	private String name;
	private int age;

	public Child(String name, int age) {
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "姓名:" + this.name + "==年龄:" + this.age;
	}

	@Override
	public boolean equals(Object obj) {// 比较方法重载,用于进行比较两个对象,并去除重复对象
		if (this == obj) {// 地址相等
			return true;// 是同一个对象
		}
		if (this == null) {// 地址为空
			if (obj != null)
				return false;// 不是同一个对象
		}
		Child temp = (Child) obj;// 进行向下转型
		if ((this.name.equals(temp.name)) && (this.age != temp.age)) {// 依次判断属性是否相等
			return true;// 全部相等,是一个对象
		} else {
			return false;
		}
	}

	@Override
	public int hashCode() {// 对于重复的判断,只覆写equals方法不够,还需要覆写hashCode方法,
	//利用指定的公式将类中全部属性进行计算,以求出一个不会重复的哈希码,从而判断不重复
		return this.name.hashCode() * this.age;// 指定哈希码编写公式
	}

	@Override
	public int compareTo(Child o) {
		if (this == o) {// 地址相等
			return 0;// 相等返回0,大于返回正数,小于返回负数
		}
		if (this == null) {// 地址为空
			if (o != null)
				return -1;
		}
		if (!this.name.equals(o.name)) {// 姓名不相等则按姓名排
			return this.name.compareTo(o.name);// 按字典顺序比较两个字符串
		}
//		return o.age - this.age;// 年龄按从o到this的顺序排
		return this.age - o.age;// 年龄按从this到o的顺序排
	}
}

集合的输出

1.     迭代输出 Iterator(最常使用):是专门的迭代输出接口,由前向后单向输出。所谓的迭代输出接口就是将元素一个个进行判断,判断其是否有内容,如果有内容则把内容取走

2.     双向迭代输出Listlterator:可以实现由后向前或者由前向后的双向输出(只有List接口才可以实现),若想要后向前输出,必须先完成由前向后的输出

3.     Foreach:增强型循环
public class IteratorTest {
	public static void main(String[] args) {
		
		//Iterator代码
		List list = new ArrayList<>();
		list.add("Hello");
		list.add("World");
		list.add("Hello");
		list.add("Java");
		Iterator itr = list.iterator();//直接实例化Iterator接口
		while (itr.hasNext()){// 是否有下一个数据
			String str = itr.next();
			if("Java".equals(str)){//判断内容里是否有“I”
				itr.remove();//如果有就删除该元素
			}
		}
		System.out.println("使用Iterator:" + list);
		
		//ListIterator代码
		System.out.println("========================");
		List list1 = new ArrayList();
		list1.add("Hello");
		list1.add("World");
		list1.add("Hello");
		list1.add("Java");
		ListIterator litr = list1.listIterator();
		System.out.print("使用ListIterator由前向后输出:");
		while (litr.hasNext()) {
			String string = litr.next();
			System.out.print(string + "、");
		}
		System.out.println();
		System.out.print("使用ListIterator由后向前输出:");
		while (litr.hasPrevious()) {
			String string = litr.previous();
			System.out.print(string + "、");
		}
		
		//Foreach代码
		System.out.println();
		System.out.println("=========================");
		List list2 = new ArrayList();
		list2.add("Hello");
		list2.add("World");
		list2.add("Hello");
		list2.add("Java");
		System.out.print("使用foreach输出:");
		for (String str : list2) {
			System.out.print(str + "、");
		}
	}
}
//使用Iterator:[Hello, World, Hello]
//========================
//使用ListIterator由前向后输出:Hello、World、Hello、Java、
//使用ListIterator由后向前输出:Java、Hello、World、Hello、
//=========================
//使用foreach输出:Hello、World、Hello、Java、


Map:

Collection、Set、List接口都属于单值的操作,每次只能操作一个对象,而Map每次操作的是一对对象,Map的每个元素都用key→value的形式存储在集合中

1.     Map.Entry接口简介:是Map内部定义的一个接口,专门用来保存key→value的内容(实际上是将key→value的数据保存在Map.Entry的实例后,再在Map集合中插入一个个的Map.Entry的实例化对象)


2.     HashMap:无序存放,新的操作类,key不允许重复

3.     HashTable:无序存放,旧的操作类,key不允许重复(除了Hashtable可以同步和不允许使用null之外, Hashtable与HashMap类大致相同)


4.    TreeMap:可以排序的Map集合,按集合中的key排序,key不允许重复(一般使用的String类作为key,而String类已经实现了Comparable接口,所以不用再特意实现,而如果使用自定义的类作为key,则必须实现Comparable接口,否则会出现异常)
public class MapTest {
	public static void main(String[] args) {
		
		//HashMap代码
		Map map = null;
		map = new HashMap();
		map.put("a", 97);
		map.put("b", 98);
		map.put("c", 99);
		map.put("d", 100);
		map.put(null, null);//HashMap允许放入null,而HashTable不可以
		
		System.out.println(map);
		map.put("a", 0);// 会将之前相同Key值的value值覆盖
		System.out.println(map);
		System.out.println("字母a的ASCII码:" + map.get("a"));//根据key值得到value值
		System.out.println("有没有b的ASCII码:" + map.containsKey("b"));//查找指定的key是否存在
		System.out.println("有没有ASCII码等于100的字母:" + map.containsValue(100));//查找指定的value是否存在
		System.out.println("map是否为空:" + map.isEmpty());
		System.out.println("map中有多少数据:" + map.size());
		map.remove("d");
		System.out.println("删掉d后,map中有多少数据:" + map.size());

		System.out.println("===============================");
		Set keys = map.keySet();//得到全部的key
		System.out.print("全部的key:");
		for (String k : keys) {//利用增强型循环输出
			if("a".equals(k)){
				map.put("a", 55);//利用put将a的值更改
			}
			System.out.print(k + "、");
		}
		System.out.println();
		Collection values = map.values();//得到全部的value
		Iterator itr1 = values.iterator();//利用Iterator进行输出
		System.out.print("全部的value:");
		while(itr1.hasNext()){
			Integer string1 = itr1.next();
			System.out.print(string1 + "、");
		}
		System.out.println();
		System.out.println("================================");
		map.clear();
		System.out.println("清空操作后,map是否为空:" + map.isEmpty());
		
		Map map1 = new HashMap<>();
		map1.put("q", 7);
		map1.put("w", 8);
		map1.put("e", 9);
		map.putAll(map1);//将map1的所有数据放入map中
		System.out.println("放入map1后的map:" + map);
		System.out.println("map1:" + map1);
		
		System.out.println();
		Set> entrys = map.entrySet();//可以同时得到key与value的值的列表
		for (Map.Entry entry : entrys) {
			System.out.println("key:" + entry.getKey() + " value:" + entry.getValue());
		}
		
		//TreeMap代码
		System.out.println("============================");
		Map treeMap = new TreeMap();
		treeMap.put("C", "张三");
		treeMap.put("A", "李四");
		treeMap.put("B", "李四");
		treeMap.put("A", "王五");
		Set treeSet = treeMap.keySet();
		Iterator treeItr = treeSet.iterator();
		while(treeItr.hasNext()){
			String treeStr = treeItr.next();
			System.out.println(treeStr + "--->" + treeMap.get(treeStr));//取出key对应的key值
		}
	}
}

//{null=null, d=100, b=98, c=99, a=97}
//{null=null, d=100, b=98, c=99, a=0}
//字母a的ASCII码:0
//有没有b的ASCII码:true
//有没有ASCII码等于100的字母:true
//map是否为空:false
//map中有多少数据:5
//删掉d后,map中有多少数据:4
//===============================
//全部的key:null、b、c、a、
//全部的value:null、98、99、55、
//================================
//清空操作后,map是否为空:true
//放入map1后的map:{w=8, e=9, q=7}
//map1:{w=8, e=9, q=7}
//
//key:w value:8
//key:e value:9
//key:q value:7
//============================
//A--->王五
//B--->李四
//C--->张三

5.     WeekHashMap:弱引用,之前的子类都是强引用保存,即里面的内容不管是否使用都始终在集合里,而WeekHashMap则当利用“System.gc()”进行垃圾收集时,集合会自动清理暂时不用的数据


6.     Key可以重复的Map集合:IdentityHashMap

        只要key地址不是相等的,就可以添加进去而不被覆盖

Map接口使用的注意事项

1.     不能直接使用迭代输出Map中的全部内容(Map一般很少直接输出,只是作为查询使用,而Collection接口一般用来传递内容和输出)

   1)    使用Iterator输出(最标准的操作流程)

1>  将Map的实例通过entrySet方法变为Set接口对象

2>  通过Set接口实例化为Iterator实例化

3>  通过Iterator迭代输出,每个内容都是Map.Entry的对象

4>  通过Map.Entry进行key→value的分离
Set treeSet = treeMap.keySet();
		Iterator treeItr = treeSet.iterator();
		while(treeItr.hasNext()){
			String treeStr = treeItr.next();
			System.out.println(treeStr + "--->" + treeMap.get(treeStr));

   2)    Foreach输出(将Map集合变为Set集合进行输出)

Set> entrys = map.entrySet();//可以同时得到key与value的值的列表
		for (Map.Entry entry : entrys) {
			System.out.println("key:" + entry.getKey() + " value:" + entry.getValue());

2.     直接使用非系统的类作为key

        如果使用的自定义的类表示Map中的value,则按照格式完成即可,但是,如果要使用一个自定义的对象表示Map中的key,则对象所在的类中一定要覆写equals()和hashCode()方法,否则无法找到对应的value(类似于treeSet处,需要一一进行比较)

其他集合类

1.     Stack类:栈,先进后出。

2.     属性类:Properties

public class PropertiesDemo {
	public static void main(String[] args) {
		Properties prop = new Properties();
		prop.setProperty("system.language", "zh_CN");//设置属性
		prop.setProperty("color", "red");
		prop.setProperty("font", "黑体");
		prop.setProperty("font.style", "bold");
		
		System.out.println("配置的颜色"+prop.getProperty("color"));//根据key值取得属性的value,如果没有则返回null
		System.out.println("字体样式"+prop.getProperty("style"));//未找到则返回null
		
		String style = prop.getProperty("style","normal");
		System.out.println("字体样式"+style);
		
		prop.list(System.out);//将属性按列表输出到指定的输出流(此处为控制台)
		try {
			prop.store(new FileOutputStream("c:config.txt"), "系统配置");
			//将prop中的配置保存到C盘中的config文件中,并设置注释内容
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

//配置的颜色red
//字体样式null
//字体样式normal
//-- listing properties --
//font.style=bold
//color=red
//font=黑体
//system.language=zh_CN



版权声明:本文为博主原创文章,未经博主允许不得转载。

JAVA 类集

类集的概念是从JDK 1.2 之后正式完善的一套开发架构,其基本的作用就是完成了一个动态的对象数组,里面的数据元素可以动态的增加 类集提供了以下的几种接口: 单值操作接口:Collection、L...

Java集合类详解

Collection ├List │├LinkedList │├ArrayList │└Vector │ └Stack └Set Map ├Hashtable ├HashMap └WeakHashMa...

JAVA学习笔记13:IO&类集

完成一个学生管理程序,使用学号作为键添加5个学生对象,并可以将全部的信息保存在文件中,可以实现对学生信息的学号查找、输出全部学生信息的功能。...

14. JAVA 枚举(Enum、类集EnumMap&EnumSet 、实现接口、定义抽象方法) ----- 学习笔记

本章目标: 1

13. Java类集 Part 2(Map接口、SortedMap接口、集合工具类Collection、Stack类、属性类Properties) ----- 学习笔记

13.7  Map接口       13.7.1

专题笔记--Java 类集框架

Java 类集框架1. Java类集框架产生的原因        在基础的应用中,我们可以通过数组来保存一组对象或者基本数据,但数组的大小是不可更改的,因此出于灵活性的考虑和对空间价值的担忧,我们可以...

Java类集,整理总结的笔记

  • 2011年11月24日 22:30
  • 683KB
  • 下载

Java基础知识学习四(类集框架)

主要包括 一、Collection  :List (ArrayList,LinkedList)、 Set (HashSet,TreeSet)  输出 二、Map:HashMap,TreeMap 三、...

13. Java类集 Part 1(类集、Collection接口、List接口、Set接口、SortedSet接口、集合的输出) ----- 学习笔记

本章目标:

Java类集学习(六)应用范例(一对多的关系)

使用类集可以表示出以下关系:一个学校可以包含多个学生,一个学生属于一个学校。这是一个典型的一对多的关系。 学生含有的属性:姓名,年龄,对应的学校; 学校的属性:学校名称,对应的学生集合。 分析存...
  • yels303
  • yels303
  • 2015年12月30日 21:53
  • 298
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:JAVA学习笔记整理六(类集框架)
举报原因:
原因补充:

(最多只允许输入30个字)