java容器collections、ArrayList、List、Set、Map学习总结1

package cm;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;

import cm.P;

public class test20180408 {

	public static void main(String[] args) {
		//所有的collection容器拥有iterator（）方法，返回一个iterator迭代器。
		// try {
		// Class s=Class.forName("cm.P");
		// Constructor[]
		// cons=s.getConstructors();//getconstructors方法返回一个constructor数组，里边包含这个class对象的构造器方法
		// //如果这个类是private则默认生成的缺省构造器也是private的，getconstructors无法返回，getconstructors能返回public类型的构造器。
		// P.sopl(cons[0]+"");
		// } catch (ClassNotFoundException e) {
		// e.printStackTrace();
		// }

		P.sopl("----------------------------------------------------------对象的集合总结");
		// 集合（collection）的作用一时使我们不用创建具名引用来持有每一个对象，collection中包含多种子集，如数组等。
		// 数组时简单的线性序列，访问效率高。声明一个数组，相当于声明了一个数组对象，数组的大小声明周期就被决定了。
		// 数组能保存基本数据类型，而其他容器不能
		// 数组知道能保存特定类型的数据，其他容器可能能保存任意类型对象。
		// length为数组中唯一一个能访问的属性或方法。

		// Arrays类
		// 存在于java.util中
		// Arrays类中包含一系列静态方法
		// Arrays.equals()比较两个数组是否相等,比较两个数组想不想等是基于内容的。
		// int[] i = new int[5];
		// int[] j = { 1, 2, 3, 4, 5 };
		// System.arraycopy(j, 0, i, 0, 5);
		// P.sopl("" + Arrays.equals(i, j));// true
		// String[] s = new String[5];
		//
		// // Arrays.fill()使用某个值填充整个数组
		// Arrays.fill(s, "HI");
		// String[] b = { "HI", "HI", "HI", "HI", "HI" };
		// P.sopl("" + Arrays.equals(s, b));// true

		// Arrays.sort()对数组进行排序
		// 使用内置的排序（一个类型实现了compareto方法）方式就可以对基本类型的数据进行排序，也可以对对象数组进行排序
		// 实际上所有实现了 Comparable 接口的 Java 核心类的结果都和 equlas 方法保持一致。

		// 实现了 Comparable 接口的 List 或则数组可以使用 Collections.sort() 或者 Arrays.sort() 方法进行排序。
		// Random r = new Random();
		// compType[] a = new compType[10];
		// for (int ii = 0; ii < 10; ii++) {
		// a[ii] = new compType(r.nextInt(100), r.nextInt(100));
		// }
		// Arrays.sort(a);//
		// 如果传入类型a已经实现了比较器则不用传入比较器，也可以传入其他比较器进行比较。传入其他比较器的地方一般为排序类中的方法如Arrays.sort()、collection.sort()。
		// P.sopl("after sorting a=" + Arrays.asList(a));
		// String abc=new String ("a");
		// String bcd=new String ("B");
		// P.sopl("ABC>dbc?"+abc.compareTo(bcd));//String类实现的比较方法是字典序的比较方法，小写大于大写，b大于a。

		// 传入步骤
		// 1.创建一个实现 Comparator 接口的对象
		// Comparator comparator = new Comparator() {
		// @Override
		// public int compare(Object object1, Object object2) {
		// if (object1 instanceof NewBookBean && object2 instanceof NewBookBean){
		// NewBookBean newBookBean = (NewBookBean) object1;
		// NewBookBean newBookBean1 = (NewBookBean) object2;
		// //具体比较方法参照 自然排序的 compareTo 方法，这里只举个栗子
		// return newBookBean.getCount() - newBookBean1.getCount();
		// }
		// return 0;
		// }
		// };
		//
		// //2.将此对象作为形参传递给 TreeSet 的构造器中
		// TreeSet treeSet = new TreeSet(comparator);
		//
		// //3.向 TreeSet 中添加 步骤 1 中 compare 方法中设计的类的对象
		// treeSet.add(new NewBookBean("A",34));
		// treeSet.add(new NewBookBean("S",1));
		// treeSet.add( new NewBookBean("V",46));
		// treeSet.add( new NewBookBean("Q",26));

		// java中排序就需要对数据进行比较，一种方法就是实现java.lang.Compareable接口，该接口只有一个compareTo（）方法
		// 此方法需要一个object作为参数，如果当前对象比object小返回负值，相等返回0，大于返回正值。

		// Arrays.binarySearch()在排好序的数组中查找元素
		// int[] a = { 1, 2, 3, 4, 5 };
		// P.sopl("index="+Arrays.binarySearch(a, 4));
		// P.sopl("index="+Arrays.binarySearch(a,
		// 416));//如果目标在数组中查找不到，则会抛出负索引，负索引的值为数组的-(插入点)-1;插入点就是此元素放入有序数组的位置。
		// Arrays.asList()将数组转换为一个List容器
		// system.arraycopy()复制数组
		// int[] i = new int[5];
		// int[] j = { 1, 2, 3, 4, 5 };
		// System.arraycopy(j, 0, i, 0, 4);
		// for (int a = 0; a < 5; a++) {
		// P.sopl(""+i[a]+":"+j[a]);
		// }

		// 数组在写程序的时候就写定了容量大小，容器则不同，容器能自动调整容量，允许你放任意多的对象，容器基本上分为三类，list、set、map。set容器只允许对象保存一份，map容器将一个对象和另一个对象关联起来
		// 初探collection和map
		// P.sopl(""+collectionandmap.fill(new ArrayList<Object>()));
		// P.sopl(""+collectionandmap.fill(new HashSet<>()));
		// P.sopl(""+collectionandmap.fill(new HashMap<>()));
		// 分别对ArrayList、Hashset、Hashmap进行了测试，
		// arraylist是一个有序集合，按放入元素的先后顺序排列，底层由数组实现，可放入任何类型的对象，支持泛型。
		// 容器实现了tostring（）方法，直接可以打印出集合中的结果，具有很好的可读性collection打印出来的内容用方括号括住，用逗号分割。map用大括号括住，用等号联系键值对，map有内置的排序，因而我们并s不关心元素的添加顺序
		// 如果添加元素顺序对我们很重要，我们可以使用linkhashset或linkhashmap
		// 存储任意类型的对象，并且hashset集合中的对象是唯一的，存入hashset的对象必须是已经是实现了hashcode方法和equals方法的，这两个方法用于hashset的比较两个对象是否相等。
		// hashmap存储的是键值对类型的数据

		// 将对象存入容器时容器将丢失对象的类型信息，因此容器可以存放任何类型，除了基本类型
//		 ArrayList<Object> mm = new ArrayList<Object>();//
		// 这里将arraylist<cat>则mm集合中只能存放cat类型的对象。
		// mm.add(new cat());
		// mm.add(new dog());
		// P.sopl("" + mm.get(1).toString());
		// P.sopl("" + mm.size());//返回容器中有多少个元素

		
		//对于String类型，如果进行如System.out.println(""+object)这样的操作，则编译器会调用object对象里的toString方法，将对象转翻译为一个字符串，默认object对象里的tostring返回对象的地址，但是一般继承了object的类都重写了toString方法，如果你想打印某个子类的地址可以调用super（）.toString(()
		
		
		
		//迭代器1.要求容器返回一个iterator。2.第一次调用next（）方法返回容器中的第一个对象。3再次使用返回容器中的下一个对象。4使用hasnext()检查是否还有元素。5.remove将上一次的元素从容器中移除。
		// ArrayList<Object> ar=new ArrayList<Object>();
		// ar.add(new cat());
		// P.sopl(""+ar);//这里直接将一个容器输出，输出时调用容器的tostring，容器的头String方法便利每个对象并调用他们的toString方法
		// Iterator<Object> it=ar.iterator();
		// P.sopl(""+it.next().toString());
		// it.remove();
		// P.sopl(""+new cat());//==P.sopl(""+new cat().toString());

		//优美的代码只与接口打交道，仅在创建容器的时候才申明确切的类型;
		//如：List x=new LinkedList()好处是比较灵活，当你想使用另一种容器的时候比如arraylist
		//就可以List x =new ArrayList()而不用更改程序中的其他代码。
		
		
		// String [][]s ={{"i","am"},{"you","what"}};
		// P.sopl(s[0][1]+"");
		
		//List有get方法支持随机快速访问，而set没有get方法，因为set有自己内部实现的排序机制，如果想检查collection中的元素就要用到迭代器iterator；
		
	}

}

class compType implements Comparable<Object> {
	int i, j;

	public compType(int n1, int n2) {
		i = n1;
		j = n2;
	}

	@Override
	public int compareTo(Object x) {// 比较器接受了object类型的对象，下面使用强制类型将其向下转型
		int xi = ((compType) x).i;
		return (i < xi ? 1 : (i == xi ? 0 : -1));
	}

	public String toString() {
		return "i=" + i + ":j=" + j;
	}

}

class collectionandmap {
	static Collection<Object> fill(Collection<Object> c) {
		c.add("cat");
		c.add("pig");
		c.add("pig");
		return c;

	}

	static Map<Object, Object> fill(Map<Object, Object> m) {
		m.put("cat", "catname");
		m.put("pig", "pigname");
		return m;

	}
}

class cat {
	String name;

	public String toString() {
		return "this a cat";
	}
}

class dog {
	String name;
}