学习-集合框架

　　集合:装东西的容器;

　　框架:为了打到某一目的或者实现某个功能,而预先设计好的一系列具有继承或实现关系的类与接口;

　　Collection接口,常用的集合或是他的直接实现类,或是有间接关系;

　　三种常用集合:

　　一.List

　　特点:a.线性,就是有序的意思,有下标,元素放入集合的顺序就是他存放元素的顺序;

　　　　 b.可以放入重复元素;

　　1.ArrayList

　　ArrayList在内存中依然是连续内存地址,这样做的优点是:查找元素效率高;往末尾添加元素效率高;

　　List的另一个子类Vector的元素存放方式与ArrayList一样,所以常把他们拿来比较,ArrayList是线程不安全的但是效率高;Vector是线程安全的但是效率低.

　　常用操作:

public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList array = new ArrayList();
		//增
		array.add(1000);
		array.add("hello");
		array.add("world");
		array.add(new Object());
		//获取集合中元素的数量
		int num = array.size();
		//删
		array.remove(1);
		//查
		Object obj = array.get(2);
		//改
		array.set(1, "helloworld");
	}

　　2.LinkedList

　　LinkedList在方法与效果上与ArrayList相同,不同的是元素的储存方式.LinkedList在内存是链式存储元素,集合的引用指向第一个元素,每个元素都有前后两个引用,前引用指向上一个元素,后引用指向下一个元素,第一个元素的前引用为null,最后一个的后引用为null;缺点是,在查找时,必须按顺序一个个的去找;优点是:内存利用率高,向中间添加数据方便.

　　二.Set

　　特点:放入的元素无序不重复;

　　常用的Set是HashSet,他通过两个方法判断放入元素是否重复:1.两个对象的equals返回true表示内容相同;

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  2.两个对象的HashCode一致为相同;

　　必须两个都不相同才能放入集合.

　　常用方法:

public static void main(String[] args) {
		HashSet hs = new HashSet();
		//增
		hs.add(new ArrayList());
		hs.add("hello");
		//查看集合中元素个数
		int num = hs.size();
		//删
		hs.remove(1);
	}

　　由于是无序存放所以没有下标的说法,没办法操作其中某个元素

　　三.Map

　　特点:元素以键值对的形式存入集合;一个键对应一个值;键和值都可以是任意自定义类型;每个键都是唯一的不能重复,值可以有重复.

　　1.常用的Map是HashMap,他判断键是否相等的方式与HashSet一样

　　常用方法:

　　

		// TODO Auto-generated method stub
		/*
		 * Map集合--映射--元素是以键值对的方式，成对表示的。
		 * 键不能重复，但是值可以重复
		 * 键与值都可以是任意数据类型
		 * 
		 */
		
		HashMap<Integer, Student> map = new HashMap<Integer, Student>();
		
		//增
		map.put(12901, new Student(12901,"zhang3",23));
		map.put(12902, new Student(12902,"li4",21));
		map.put(12903, new Student(12903,"wang5",24));
		
		//删
		map.remove(12902);
		
		//查
		Student stu = map.get(12901);
		System.out.println(stu);
		
		//改
		map.put(12901, new Student(12901,"zhang3",32));
		
		System.out.println(map.size());
		
		//得到map中所有的key
		Set<Integer> keySet = map.keySet();
		for(Integer key : keySet){
			System.out.println(key);
		}
		 
		//得到map中所有的值
		Collection<Student> values = map.values();
		for(Student tmpStu : values){
			System.out.println(tmpStu);
		}
		
		//是否包含某个键
		System.out.println(map.containsKey(12904));
		//是否包含某个值
		System.out.println(map.containsValue(new Student(12901,"zhang3",32)));
	

　　　HashMap与HashTable的区别:a.HashMap不允许使用null做键,线程不安全;

　　　　　　　　　　　　　　　　　b.HashTable允许其中一个键是null,线程安全;

　　2.Properties-一个特殊的Map

　　特点:a.是属于Map的集合类

　　　　 b.可以直接操作文件-属性文件(Properties文件)一种专属的文本文件.

　

public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*
		 * Properties---属于Map分支的一种集合类;
		 * 				可以操作一种专属格式的文本文件(属性文件，properties文件)
		 */
		
		Properties props = new Properties();
		//增
//		props.setProperty("J120", "J120-123456-10000.0");
//		props.setProperty("J121", "J121-123456-11000.0");
//		props.setProperty("J122", "J122-123456-12000.0");
		
		//取
//		String value = props.getProperty("J121");
//		
//		//改
//		props.setProperty("J121", "J121-123456-11200.0");
//		
//		//删除
//		props.remove("J121");
//		
//		//同样拥有Map的其他常用方法
//		props.containsKey("J121");
//		Set<Object> allKey = props.keySet();
//		Collection<Object> allValues = props.values();
//		for(Object key : allKey){
//			String strKey = (String)key;
//		}
		
		
		//写文件---不能单独写入某一个键值对，只能全部写入
		//store方法两个参数：1、文件输出流，参数是文件的名字和位置；2、注释，可以不写那就传入null或空串
//		try {
//			props.store(new FileOutputStream("properties/user.data"), null);
//		} catch (FileNotFoundException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		} catch (IOException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
		
		//读文件
		try {
			props.load(new FileInputStream("properties/user.data"));
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		Collection allValues = props.values();
		for(Object values : allValues){
			String strValue = (String)values;
			System.out.println(strValue);
		}
	}

　　四.集合工具

　　1.遍历:a.for-each循环

　　

		// TODO Auto-generated method stub
		/*
		 * for-each循环专用（只能用作）对集合进行遍历(所谓遍历--指代把集合中的每个元素取出来，操作一次。);
		 * 支持数组、List、Set
		 */
		
		int[] array1 = new int[]{1,3,5,7,9};
		
//		for(int i = 0; i < array1.length; i++){
//			System.out.println(array1[i]);
//		}
		
//		for(int tmp : array1){
//			System.out.println(tmp);
//		}
		
		
		ArrayList<String> lst = new ArrayList<String>();
//		lst.add("hello");
//		lst.add("world");
//		lst.add("hell");
//		
//		for(String str : lst){
//			System.out.println(str);
//		}
		
		
		HashSet<Integer> set = new HashSet<Integer>();
		set.add(100);
		set.add(120);
		set.add(102);
		set.add(200);
		set.add(122);
		
		for(int in : set){
			System.out.println(in);
		}
		
	

　　　　　　　　　　b.迭代器(Iterator)

　　支持遍历的集合:a.数组支持普通for循环,for-each循环;

　　　　　　　　　 b.List支持普通for循环,for-each循环,迭代器;

　　　　　　　　　 c.Set支持for-each循环,迭代器;

　　2.泛型

　　现在对这个理解得不多,只知道泛型作用在集合上可以限制存入元素的类型

　　3.集合工具类:Collections类,Arrays类

　　

public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 1、addAll---一次往集合中放入多个元素
		ArrayList<String> lst1 = new ArrayList<String>();
		lst1.add("J129");
		lst1.add("J120");
		lst1.add("J121");

		ArrayList<String> lst2 = new ArrayList<String>();
		lst2.add("J124");
		lst2.add("J127");
		lst2.add("J128");
		
		Collections.addAll(lst2, lst1.get(0),lst1.get(1),lst1.get(2),"hello","world");

		//max\min---得到集合中最大的元素和最小的元素
		String max = Collections.max(lst1);
		String min = Collections.min(lst2);
		System.out.println(max);
		System.out.println(min);
		
　　　　　　　　　 //排序方法只支持List
		//reverse---把一个集合倒序排列，也称之为反转
		System.out.println("反转前=====================");
		for(String str : lst2){
			System.out.println(str);
		}
		Collections.reverse(lst2);
		System.out.println("反转后=====================");
		for(String str : lst2){
			System.out.println(str);
		}
		
		//sort---把集合排序
		Collections.sort(lst2);
		System.out.println("排序后=====================");
		for(String str : lst2){
			System.out.println(str);
		}
		//shuffle---随机混排
		Collections.shuffle(lst2);
		System.out.println("排序后=====================");
		for(String str : lst2){
			System.out.println(str);
		}
		
	}

　　五.补充知识点:

　　1.JDK1.5以后数组作为方法形参的新语法

public void test(){
		
		int[] array  = new int[5];
		array[0] = 1;
		
		testArray(array);
		testArray(1,2,3,4,5,6,7,8,9);
	}
	
	//JDK1.5之后用数组做参数的新语法
	public void testArray(int... array){
		System.out.println(array[0]);
		System.out.println(array.length);
	}

　　2.比较器

　　　　a.内部比较器-Compareable接口

　　　　参与比较的类实现Compareable接口,重写比较方法,传入一个同类型对象,自定义当前对象与传入对象比较内容,得到当前对象与传入对象的位置差,为正则表示当前对象排在传入对象之后,为负则表示当前对象排在传入对象之前.

　　　　b.外部比较器-Comparator接口

　　　　需要新建一个专门用于比较的类实现Comparator接口,传入2个对象,自定义前对象与后对象比较内容,得到前对象与后对象的位置差,为正则表示前对象排在后对象之后,为负则表示前对象排在后对象之前;

　　在外部比较器不参与时,元素比较使用内部比较器;当外部比较器参与比较则内部比较器失效.

转载于:https://www.cnblogs.com/yutanggege/p/5839731.html