java基础之集合类
1、java集合概略图
2、集合示例（Collection接口的15个方法）
@Test
public void test(){
Collection coll = new ArrayList();
//1、size（）：返回集合中元素
System.out.println(coll.size());
//2、add（Object obj）：向集合中添加一个元素
coll.add(123);
coll.add(new String ("AA"));
coll.add(new Date());
coll.add("BB");
System.out.println();
//3、AddAll（Collection coll）:将形参coll中包含的所有元素添加到当前集合中
Collection coll1 = Arrays.asList(1,2,3);
coll.addAll(coll1);
System.out.println(coll);
System.out.println(coll.size());
//4、isEmpty（）：判断集合是否是空
System.out.println(coll.isEmpty());
//5、clear（）：清空集合元素
coll.clear();
System.out.println(coll.isEmpty());
}@Test
public void test2(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(new String ("AA"));
coll.add(new Date());
coll.add("BB");
coll.add(new Person("MM", 23));
System.out.println(coll);
//6、contains（Object obj）：判断集合中是否包含执行的obj元素，如果包含返回true，如果不包含，返回false
//判断依据：根据元素所在类的equals（）方法进行判断。
boolean b1 = coll.contains(123);
boolean b2 = coll.contains(new String ("AA"));
System.out.println(b2);
//7、cotainsAll(Collection coll):判断当前集合中是否包含coll中的所有元素，如果包含，返回true；反之返回false。
Collection coll1 = new ArrayList<>();
coll1.add(123);
coll1.add(new String("AA"));
boolean b3 = coll.containsAll(coll1);
System.out.println(b3);
//8、retainAll（Collection coll）:求当前集合与coll的共有元素，返回给当前集合
coll1.add(456);
coll.retainAll(coll1);
System.out.println(coll);
//9、remove（Object obj）：删除集合中的obj元素，若删除成功，返回true；否则，返回false；
boolean b4 = coll.remove("BB");
System.out.println(b4);
coll.removeAll(coll1);
System.out.println(coll);
}@Test
public void Test3(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(new String ("AA"));
coll.add(new Date());
coll.add("BB");
coll.add(new Person("MM", 23));
Collection coll1 = new ArrayList<>();
coll1.add(123);
coll1.add(new String("AA"));
//10、removeAll（Collection coll） ：从当前集合中删除包含在coll中的元素（即取两个集合的差集）
coll.removeAll(coll1);
System.out.println(coll);
//11、equals(Object obj)
Collection coll2 = new ArrayList<>();
coll2.add(123);
coll2.add(new String("AA"));
boolean b1 = coll1.equals(coll2);
System.out.println(b1);
//13、toArray()：将集合转化成数组
Object[] objs = coll.toArray();
for(Object object : objs){
System.out.println(object);
}
//14、iterator（）：返回一个Iterator接口实现类的对象,进而实现集合的遍历
Iterator iterator = coll.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
* 集合：
* Collection接口：
* |--List接口：存储有序的，可以重复的元素
* |--ArrayList(主要的实现类)、LinkedList（对于频繁的插入或者删除操作，建议选择）、vector
* |--Set接口：存储无序的，不可重复的元素
* |--HashSet（主要实现类）、LinkedHashSet、TreeSet
* Map接口：存储“键-值”对数据
* |--hashMap、LinkedHashMap、TreeMap、HashTable（子类--properties）3、List接口
//ArrayList:List的主要实现类
@Test
public void test(){
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(new String("AA"));
list.add(new String("BB"));
//add(int index,Object obj):在指定的索引位置index添加元素obj
list.add(0, 555);
System.out.println(list);
//get(int index):获取指定索引的元素
Object object = list.get(1);
System.out.println(object);
//Object remove(int index):删除指定索引位置的元素。（注：Collection中也有remove方法，不过那是删除指定的对象，而不是指定索引的元素）
list.remove(0);
//Object set(int index , Object obj):设置指定索引位置的元素为obj
list.set(0, "miehaha");
System.out.println(list.get(0));
}
@Test
public void test1(){
//indexof（Object obj）：返回obj在集合中首次出现的位置。没有的话，返回-1.
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(new String("AA"));
list.add(new String("BB"));
System.out.println(list.lastIndexOf(456));
}4、重要：Set（HashSet（用的最多，数据不可重复，里面根据hashcode（）和equals（）进行数据的存储）、LinkedhashSet(按照插入的顺序进行输出)）
/*
* Set:存储的元素是无序的，不可重复的
* 1、无序性：无序性 ！=随机性。真正的无序性，指的是元素在底层存储的位置是无序的。
* 2、不可重复性：当向set中添加进相同的元素的时候，后面的这个不能添加进去。
* 说明：要求添加进Set中元素所在的类，一定要重写equals（）和hashcode（）方法。
* 进而保证Set中元素的不可重复性。
*
* Set集合中为了保证数据的不可重复存储采用了哈希算法。
* 当向Set中添加元素时，首先调用此对象的hashcode（）方法，计算此对象的hashcode（）值，此哈希值决定了对象在Set中的存储位置，若此位置之前没有对象存储，则这个对象直接存到这个位置；
* 若此位置已有对象存储，再通过equals（）方法比较这两个对象是否相同，如果相同，后一个对象就不能再添加进来。
* 此时要求hashcode（）和equals（）方法要一致。
*/主要其中hashcode（）和equals（）在Set接口中存储数据时的原理。
即存储时，首先查看两个对象hashcode（）值是否相同，如果相同，那么比较通过equals（）比较两个对象是否相同，如果相同，则只存储一个对象（前面的一个）。
注：但是存在两种情况：①实际对象利用equals（）比较，是两个相同对象，可是hashcode值不同，那么这两个对象依旧可以存储进Set中。原因：对象所在类没有重写hashcode（）方法或者重写的hashcode（）不好。
②实际对象利用equals（）比较，是两个不同对象，可是他们的hashcode值却相同，那么这两个对象会存储在set集合中的一个元素位置。原因：对象所在类重写的hashcode（）不好。
5、TreeSet
public class TestSet {
/*
* TreeSet
* 1、向TreeSet中添加的元素必须是同一个类
* 2、可以按照添加进集合中的元素的指定的顺序进行遍历。像String，包装类等默认按照从小到大的顺序进行遍历。
* 3、当向TreeSet中添加自定义类的对象时，有两种排序方法：①自然排序 ②定制排序
* 4、自然排序：要求自定义类实现java。lang。Comparable接口，并重写CompareTo（Object obj）方法，
* 在此方法中，执行按照自定义类的哪个属性进行排序。
* 注：向TreeSet中添加元素时，首先按照CompareTo（Object obj）方法进行比较，一旦返回0，虽然仅是两个对象的某一约定的属性值一样，
* 但是程序会认为这两个对象是相同的，进而后一个对象就不能添加进来。
* 》CompareTo（）、hashCode（）、equals（）方法要一致。
* 5、定制排序：
* 》CompareTo（）、hashCode（）、equals（）方法要一致。
*/
@Test
public void test2(){
//1、创建一个实现了Comparator的对象
Comparator comparator = new Comparator() {
//向Treeset中添加customor类的对象，在此compare（）方法中，致命是按照customor的哪个属性进行排序。
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Customer && o2 instanceof Customer ){
Customer c1 = (Customer) o1;
Customer c2 = (Customer) o2;
int i = c1.getId().compareTo(c2.getId());
if(i == 0){
return c1.getName().compareTo(c2.getName());
}else {
return i;
}
}
return 0;
}
};
//2、将此对象作为形参传递给TreeSet的构造器中
TreeSet set = new TreeSet(comparator);
//3、向TreeSet中添加Comparator 接口中的compare方法中涉及的类的对象。
set.add(new Customer("AA", 1001));
set.add(new Customer("BB", 1002));
set.add(new Customer("DD", 1003));
set.add(new Customer("CC", 1001));
for(Object object : set){
System.out.println(object);
}
}
@Test
public void test1(){
Set set = new TreeSet();
//当person类没有实现Comparable接口时，当向TreeSet中添加Person对象时，报ClassCastException
set.add(new Person("AA", 20));
set.add(new Person("DD", 23));
set.add(new Person("DD", 24));
set.add(new Person("CC", 23));
set.add(new Person("KK", 23));
for(Object obj:set){
System.out.println(obj);
}
}
/*
* Set:存储的元素是无序的，不可重复的
* 1、无序性：无序性 ！=随机性。真正的无序性，指的是元素在底层存储的位置是无序的。
* 2、不可重复性：当向set中添加进相同的元素的时候，后面的这个不能添加进去。
* 说明：要求添加进Set中元素所在的类，一定要重写equals（）和hashcode（）方法。
* 进而保证Set中元素的不可重复性。
*
* Set集合中为了保证数据的不可重复存储采用了哈希算法。
* 当向Set中添加元素时，首先调用此对象的hashcode（）方法，计算此对象的hashcode（）值，此哈希值决定了对象在Set中的存储位置，若此位置之前没有对象存储，则这个对象直接存到这个位置；
* 若此位置已有对象存储，再通过equals（）方法比较这两个对象是否相同，如果相同，后一个对象就不能再添加进来。
*/
@Test
public void test(){
Set set = new HashSet();
set.add(123);
set.add(456);
set.add("AA");
set.add("BB");
set.add(null);
set.add(new Person("zhangyy", 20));
set.add(new Person("zhangyy", 20));
System.out.println(set.size());
System.out.println(set);
}
}6、Map
/*
* Map接口：
* |--HashMap:Map的主要实现类,key使用Set来存储的，不可重复；value使用Collection来存储的，可重复的。
* 一个key—value对，是一个Entry。所有的Entry使用Set来存放的，也是不可重复的。
* 向hashMap中添加元素时，会调用key所在类的equals（）方法， 判断两个key是否相同，若相同，则只能添加进一个（是后一个添加进的元素）。
* |--LinkedHashMap：使用链表维护添加进Map中的顺序，所以遍历Map时，是按照添加的顺序遍历的。
* |--TreeMap：按照添加进Map中元素的Key的指定属性进行排序。要求Key必须是同一个类对象！（key值排序方式与TreeSet中的排序类型一致：自然排序和定制排序）
* |--HashTable：古老的实现类，线程安全的，不建议使用。
* |--Properties：常用来处理属性文件，键和值都是String类型。
*
*/
public class TestMap {
/*
* 遍历map：
* Set keySet()
* Collection values()
* Set entrySet()
*/
@Test
public void test2(){
Map map = new HashMap();
//put:向map中添加一个元素
map.put("AA", 123);
map.put("BB", 456);
map.put(null, null);
map.put("CC", 789);
map.put(123, "AA");
//遍历key集
Set set =map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()){
//Object obj = map.get(iterator.next());
System.out.println(iterator.next());
}
//遍历values
Collection value = map.values();
Iterator iterator2 = value.iterator();
while(iterator2.hasNext()){
System.out.println(iterator2.next());
}
//如何遍历key-value对：采用EntrySet
Set set2 = map.entrySet();
for(Object obj:set2){
Entry entry = (Entry) obj;
System.out.println(entry.getKey() +"--->"+entry.getValue());
}
}
@Test
public void test1(){
Map map = new HashMap();
//put:向map中添加一个元素
map.put("AA", 123);
map.put("BB", 456);
map.put("BB", "1111111111111");
map.put("CC", 789);
map.put(123, "AA");
map.put(null, null);
System.out.println(map.size());
map.remove("BB");
System.out.println(map);
Object valueObject = map.get(123);
System.out.println(valueObject);
boolean b1 = map.containsKey(123);
System.out.println(b1);
boolean b2 = map.containsValue(123);
System.out.println(b2);
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
