黑马程序员——集合框架类总结

为什么会出现集合类？

Java语言是面向对象的语言，所有命令都是操作对象的，有集合类的出现就可以操作对象

 

数组和集合类的区别是什么呢？

数组中可以存储基本类型的数据，也可以存储对象，集合类只能存储对象

 

集合类的特点有什么？

集合只适用于存储对象，长度是可变化的，集合可以存储不同类型的集合。

 

集合类Collection接口，子类接口有List接口和Set接口，List接口下含有ArrayList，LinkedList，Vector接口，

Set接口下有HashSet和TreeSet接口

 

为什么会出现这么多不同的容器接口？

因为每一个容器的对数据的存储方式不一样，这个存储方式叫做数据结构，也就是说，每种容器存储数据的数据结构不一样，那

什么是数据结构呢?数据结构就是数据元素之间存储的关系。

 

Collection的接口方法

a1.add（Object obj）；增加对象进容器

a1.size（）；显示数据个数

a1.remove(Object obj）移除对象数据

a1.clear（）；清除所有对象数据

a1.retainAll（a2），取交集

a1.contains（Object obj）是否含有obj

a1.removeAll（a2）移除相同元素

 

集合中存储的都是对象的引用（地址）；

 

集合的迭代器用于取出元素

 Iterator ite = arr.iterator();

  while(ite.hasNext())

     sop(ite.next());

 

Collection接口中的List接口：元素是有序的，元素可以重复，因为该体系有索引

                               Set接口：元素是无序的，元素不可以重复.

List接口：凡是可以操作角标的方法都是该接口的特有方法

特有方法：

import java.util.*;

class ListTest

{

 public static void main(String[] args)

 {

  ArrayList a1 = new ArrayList();

  a1.add("arr1");

  a1.add("arr2");

  a1.add("arr3");

  a1.add(1,"arr4"); //在角标位置上增加arr4对象元素

  sop(a1);

 remove(2); //移除角标为2的元素

  a1.set(2,"arr7"); //修改角标为2的元素

  sop(a1);

sop(a1.indexOf("arr1"));    //    查找对象元素的位置

  sop(a1.subList(1,3));//    打印1角标到3角标的元素（不包括3角标元素）

 

  sop(a1.get(3)); //获取角标为3 的元素

 

  for(int x = 0; x < a1.size(); x++) //打印元素

  {

   sop(a1.get(x));

  }

 Iterator ite = arr.iterator();

  while(ite.hasNext())//打印元素

     sop(ite.next());

 

 }

 static void sop(Object obj)

 {

  System.out.println(obj);

 }

}

 

Iterator ite = a1.iterator();

  while(ite.hasNext())

  {

   Object obj = ite.next();

   if( obj.equals("arr7"))

   {

    ite.remove(); //不能在这写a1.add（Objext obj）,

       sop( obj);

   }

  }

 

   ListIterator ite1 = a1.listIterator();

 

  while(ite1.hasNext())

  {

   Object x = ite1.next();

   if(x.equals("arr7"))

    ite1.set("arr10");

 

   sop(x);

 

  }

 

ArryList：底层是数组数据结构，特点：查询速度快，但增删稍慢，线性不同步

LinkedList：底层使用的是链表结构，特点：增删速度快，查询稍慢

Vector：底层是数组数据结构，线性同步，被ArrayList代替了

 

Enumeration en = vec.elements();

  while(en.hasMoreElements())

  {

   System.out.println(en.nextElement());

  }//Vector独有的取出方法

 

 

List集合判断元素是否相同，依据的是元素的equals（）方法

 

Set集合的特点:元素是无序的，元素不可重复

HashSet：底层结构是哈希表

HashSet是如何保证数据的唯一性的?

HashSet中的元素先判断哈希值是否一样，如果不一样，元素不一样

如果一样，调用equals方法判断

TreeSet中用Comparable中的compareTo(Object obj)方法

或者Comparator接口中的compare(Object obj1,Object obj2)实现排序

练习
package blogtest2;
import java.util.*;
public class ArrayListTest {

 /**
  * 将自定义对象传入到ArrayList集合中，并去除重复元素
  */
 public static void main(String[] args) {
  ArrayList<People> arraylist = new ArrayList<People>();
  arraylist.add(new People("zhangshan",22));
  arraylist.add(new People("lishan",24));
  arraylist.add(new People("wangwu",15));
  arraylist.add(new People("zhangshan",22));
  ArrayList<People> singlist = singleName(arraylist);
  for(People stu : singlist){
   System.out.println(stu);
  }
 }


public static ArrayList<People> singleName(ArrayList<People> arraylist){
 ArrayList<People> list = new ArrayList<People>();
 Iterator<People> ite = arraylist.iterator();
 while(ite.hasNext()){
  People stu = ite.next();
  if(!list.contains(stu)){
   list.add(stu);
  }
 }
 return list;
}
}
class People{
 private String name;
 private int age;
 People(String name,int age){
  this.name = name;
  this.age = age;
 }
 public String getName(){
  return name;
 }
 public int getAge(){
  return age;
 }
 public String toString(){
  return name +"...."+age;
 }
 public boolean equals(Object stu){
  if(!(stu instanceof People)){
   return false;
  }
  People stucopy = (People)stu;
  return this.name.equals(stucopy.name) && this.age == stucopy.age;
 }
}

练习
package blogtest2;
import java.util.*;
public class LinkedListTest {

 /**
  * 用LinkedList模拟堆栈或者队列结构
  */
 public static void main(String[] args) {
  LinkedList<String> linkedlist = new LinkedList<String>();
  linkedlist.addFirst("java1");
  linkedlist.addFirst("java2");
  linkedlist.addFirst("java3");
  linkedlist.addFirst("java4");
  System.out.println(linkedlist);
 
  LinkedList<String> linkedlist2 = new LinkedList<String>();
  linkedlist2.addLast("java1");
  linkedlist2.addLast("java2");
  linkedlist2.addLast("java3");
  linkedlist2.addLast("java4");
  System.out.println(linkedlist2);
 
   
 }

}

练习
package blogtest2;
import java.util.HashSet;
public class HashSetTest {

 /**
  * 将自定义对象存入HashSet中，同姓名和年龄为重复元素
  */
 public static void main(String[] args) {
  HashSet<Student> hashset = new HashSet<Student>();
  hashset.add(new Student("zhangshan",22));
  hashset.add(new Student("lishan",24));
  hashset.add(new Student("wangwu",15));
  hashset.add(new Student("zhangshan",22));
  for(Student stu : hashset){
   System.out.println(stu);
  }

 }

}
class Student implements Comparable<Student>{
 private String name;
 private int age;
 Student(String name,int age){
  this.name = name;
  this.age = age;
 }
 public String getName(){
  return name;
 }
 public int getAge(){
  return age;
 }
 public String toString(){
  return name +"...."+age;
 }
 public int hashCode(){
  return this.name.hashCode() + this.age * 30;
 }
 public boolean equals(Object stu){
  if(!(stu instanceof Student)){
   return false;
  }
  Student stucopy = (Student)stu;
  return this.name.equals(stucopy.name) && this.age == stucopy.age;
 }
 public int compareTo(Student stu){
  int num = new Integer(this.age).compareTo(new Integer(stu.age ));
  if(num == 0){
   return this.name.compareTo(stu.name);
  }
  return num;
 }
}

练习
package blogtest2;
import java.util.*;
public class TreeSetTest {

 /**
  * 往TreeSet中存入自定义对象学生，按学生的年龄排序
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  TreeSet<Student> treeset = new TreeSet<Student>(new MyComparator());
  treeset.add(new Student("zhangshan",22));
  treeset.add(new Student("lishan",24));
  treeset.add(new Student("wangwu",15));
  treeset.add(new Student("zhangshan",22));
  for(Student stu : treeset){
   System.out.println(stu);
  }

 }
}
class MyComparator implements Comparator<Student>{
 public int compare(Student stu1,Student stu2){
  int num = stu1.getName().compareTo(stu2.getName());
  if(num == 0){
   return new Integer(stu1.getAge()).compareTo(new Integer(stu2.getAge()));
  }
  return num;
 }
}
class Student implements Comparable<Student>{
 private String name;
 private int age;
 Student(String name,int age){
  this.name = name;
  this.age = age;
 }
 public String getName(){
  return name;
 }
 public int getAge(){
  return age;
 }
 public String toString(){
  return name +"...."+age;
 }
  Student stucopy = (Student)stu;
  return this.name.equals(stucopy.name) && this.age == stucopy.age;
 }
 public int compareTo(Student stu){
  int num = new Integer(this.age).compareTo(new Integer(stu.age ));
  if(num == 0){
   return this.name.compareTo(stu.name);
  }
  return num;
 }
}

练习
package blogtest2;
import java.util.*;
public class HashMapTest {
 /**
  *演示Map集合两种取出方式
  */
 public static void main(String[] args) {
  Map<String,String> map = new HashMap<String,String>();
  map.put("zhangshan", "22");
  map.put("lisi", "33");
  map.put("wangwu", "44");
  map.put("xiaoming", "55");
  //第一种取出方式
  Set<Map.Entry<String, String>> set = map.entrySet();
  Iterator<Map.Entry<String, String>> ite = set.iterator();
  while(ite.hasNext()){
   Map.Entry<String, String> mapentry = ite.next();
   String key = mapentry.getKey();
   String value = mapentry.getValue();
   System.out.println(key + "=" + value);
  }
  //第二种取出方式
  Set<String> set2 = map.keySet();
  Iterator<String> ite2 = set2.iterator();
  while(ite2.hasNext()){
   String key2 = ite2.next();
   String value2 = map.get(key2);
   System.out.println(key2 + "=" + value2);
  }
 }
}