Java基础（集合）

集合

集合大概理论：

List接口

 ArrayList：实现了可变的数组，在内存中分配连续的空间，便利元素和随机访问元素的效率比较高。    LinkedList：采用链表储存方式，插入，删除元素时效率比较高！ 

set接口

 HashSet:唯一，重复，直接不能储存进去！无序的，是采用哈希吗储存的！ 

---

Collection 是层次结构根接口

List: 有序（存入和取出的顺序一致），元素都有索引（角标），储存的元素可以重复。(怎么存的元素，就怎么吧元素取出来) 　　　　　 ArrayList是List的子接口。

set: 元素不能重复，储存的元素是无序的。

---

一些collection允许有重复元素，而另一些则不允许。 一些collection是有序的，而另一些则是无序的。

由于collection是接口，所以不能new他的对象

语法：

 Collection collection  = new Collection();这种是语法错误的，因为 Collection 是接口，所以不能new，因为毫无意义。不能实例化那么我们怎么new了？ 此时我们就要找他的实现对象我们查找API 发现colletion有很多实现子类 extends collection 

---

• 所有已知实现类： AbstractCollection, AbstractList, AbstractQueue, AbstractSequentialList, AbstractSet, ArrayBlockingQueue, ArrayDeque, ArrayList, AttributeList, BeanContextServicesSupport, BeanContextSupport, ConcurrentLinkedQueue, ConcurrentSkipListSet, CopyOnWriteArrayList, CopyOnWriteArraySet, DelayQueue, EnumSet, HashSet, JobStateReasons, LinkedBlockingDeque, LinkedBlockingQueue, LinkedHashSet, LinkedList, PriorityBlockingQueue, PriorityQueue, RoleList, RoleUnresolvedList, Stack, SynchronousQueue, TreeSet, Vector

---

Collection的使用常见方法

1：添加。 boolean add(Object obj);

boolean addAll(colecton coll);

吧这个引用类型元素添加到调用此方法的引用。

---

2:删除。 boolean remvoe(Object obj);

boolean removeAll(collecton coll);

删除重复的元素，保留不重复的元素

---

3:判断 boolean contains(Object obj);

boolean contains(collection coll); 如果列表包含指定 collection 的所有元素，则返回 true。

boolean isEmpty();判断集合中是否有元素

---

4:获取 int size();

iterator iterator();取出元素的方式，迭代器

---

5:其他 boolean retainAll(collection coll);取交集。

Object[]toString();将集合转成数组。

语法： //储存数据         *ollection collection = new ArrayList();           collection.add(100);           collection.add("哈哈");           collection.add(10.1);           collection.add(false);           System.out.println("他的长度是"+collection.size()); 

这个是打印他的这个集合的长度

---

toArray() 关键词是吧集合的内容全部转为数组；

---

 public class Demo3 {     public static void main(String[]args){     Collection collection = new ArrayList();     Demo demo = new Demo(null,0);//此时这句话可以不写因为在集合里面new了这个类的无参构造。     collection.add(new Demo("哈哈哈",10));     collection.add(new Demo("嘻嘻嘻",30));     collection.add(new Demo("啦啦啦",80));     System.out.println("他的长度是"+collection.size());       Object[] obj = collection.toArray();    //因为ArrayList是实现Collection子类所以他们都是基于OBject超类     for(int i =0;i<collection.size();i++){        Demo demo =(Demo)obj[i]; //吧每次collection集合遍历的地址都给了demo对象名       System.out.println(demo.getname);       System.out.println(demo.getin);       }     } } class Demo{    private String name; // private String [] name;         private int in;//    public Demo(String ing, int in) {     this.ing = ing;     this.in = in; } public String getname(){       return name;    }    public void setname(String name){       this.name = name;    }    public int getin(){       return in;    }    public void setin(int in){       this.in = in;    } } 

---

以下new出来的是错误的，因为name 和 in 是普通值，而在遍历数组的时候，是无法加载的，除非 private String [] name; private int[] in;

或者

 System.out.println(demo.getname()); System.out.println(demo.getin()); 

后面加上();

---

---

---

addAll（）方法

用于：添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。

 import java.util.ArrayList; import java.util.Collection;  class Demo1{    public static void main(String[]args){    Collection collection = new Arraylist();    Collection collection1 = new Arraylist();    collection.add("1");    collection.add("2");    colelction.add("3");    collection1.add("2");    collection1.ada("4");    collection1.add("4");    collection.addAll(collection1);  //这句代码是将这个colleciton的元素添加到colleciton1里面    System.out.println(collection);      }   } 

---

---

---

removeAll()

用于：移除此 collection 相同的元素（重复的元素），保留不相同的元素（不重复的元素）；

 publc class Demo{   public static void main(String[]args)[    Collection collection = new ArrayList();    Collection collection1  = new ArrayList();    collection.add("1");    collection.add("2");    collection.add("3");    collection1.add("1");    collection1.add("2");    collection1.add("6"); //   System.out.println(collection.addAll(collection1));//因为removeAll是boolean，所以返回的是布尔类型    collection.addAll(collection1);    System.out.println(collection);    collection.removeAll(colleciotn1);    System.out.println(colelciton);    //这两句代码是 两个引用类型，在堆内存储存一样的元素时候，那么全部去掉，只留下两个堆内存中不重复的元素    }   } 

---

---

containsAll

如果此colleciton 包含了全部的colleciton的元素，则返回true，否则返回false

 public class Demo{  public static void main(String[]args){   Collection collection = new ArrayList();   Collection collection1 = new ArrayList();   collection.add("1");   collection.add("2");   collection1.add("1");   colelction1.add("2");   collection.containsAll(collection1);   //containsAll 如果这个包括了全部的元素，那么返回true否则就是false       } } 

---

---

retainAll()

用于：如果集合colleciton 去交集，删除collection不相同的元素，保留相同的元素，和remove相反

 public class dEMO {public static void main(String[]args){List list = new ArrayList();List list1 = new ArrayList();  yi(list,list1);}public static void yi(List<String> list,List list1){    list.add("1");    list.add("2");    list.add("3");    list1.add("6");    list1.add("2");    list1.add("3");    boolean a = list.retainAll(list1);    System.out.println(list1+"+"+list);    System.out.println(a); //取交集，保留相同的元素，干掉不相同的元素} 

}

迭代器接口 Iterator()

方法摘要:

---

hasNext() 如果仍有元素迭代，则返回true

next() 返回迭代的下一个元素

remove() 从迭代器指向的collection中移除迭代器返回的最后一个元素（可选操作）

---

一般用来遍历集合内容的

返回在此collection的元素上进行迭代的迭代器。关于元素返回没有任何保证 （除非此collection是某个能提供保证顺序的类实列）。

 Iterator iterator = demo.iterator();  //这句代码是调用集合迭代器方法，为了获取集合的迭代器对象 

语法如下:

 class Demo{public static void mian(String[]args){Collecton collection = new ArrayList();collection.add(new Demo2("哈哈",123));collection.add(new Demo2("嘻嘻嘻",1234));collection.add(new Demo2("啦啦啦",11111));System.out.println(collection.size());//size是显示集合的长度的Iterator iterator = collection.iterator();//collection.iterator(); 这句代码是 调用集合的迭代器方法，是为了获取集合中的迭代器对象//Iterator iterator 这句代码是 ，我拿到了迭代器的对象 while(iterator.hasNext){ //hasNext是条件判断，则next给hasNext返回是true还是false ，用于查看下一个有没有元素 Object obj = iterator.next();//这句话可以直接写成 Demo2 demo = (Demo2)iterator.next(); //用于：返回iterator的boolean的类型，吧每次遍历的指针给你，每次循环，达到实现属性类使用 //因为是new Demo2这个类的，所以我们get来取这个类的属性  Demo2 demo = (Demo2)obj;//因为在集合中我们new的没有指针，所以必须来遍历指针指引这个属性类 System.out.println(demo.geting()); System.out.println(demo.getin); } 

---

---

迭代器与集合错误特点：

在迭代器操作过程中，不能用集合来操作删除，添加，只能打印。

不能迭代器和集合同时对元素进行修改，添加，和删除。

 class Demo{  public static void main(String[]args){    List list = ArrayList();       yi(list);   }   public static void yi(List list){     list.add("1");     list.add("2");     list.add("3");     Iterator It = list.iterator();     while(It.hasNext){     Object obj = It.next();     if(obj.equals("2")){      list.add("55");    //在这一步把list集合元素给了迭代器，在迭代器过程中，突然使用集合来操作元素，所以报错！    //吧集合元素给了迭代器，要不集合操作，要不迭代器操作，否则出现异常报错！          }       }     } } 

如果坚决用集合迭代器来增加元素，那么我们就用迭代器的子类（listIterator）的方法实现

语法如下：

 class Demo( public static void main(String[]args){ List list = new ArrayList();  yi(list);  System.out.println(list);    }  public static void yi(List list){    list.add("1");     list.add("2");    list.add("3");    ListIterator It = list.iterator();   while(It.hasNext()){  // System.out.println(It.next());//此时不能这样，因为next是迭代器的返回，如果有两个迭代器操作时，除了此内存操作，会报错！   Object obj = It.next();    if(obj.equals.("3")){  //如果里面有这个字符串，那么进来添加一个       It.add("4");         }      }     }} 

用for循环遍历这个集合迭代器元素:、

语法如下：

 for(Iterator ii = collecton.iterator(); ii.hasNext(); ){  Demo2 dem  =(Demo2) ii.next();//迭代器获取到元素的地址，查看堆内存中是否为空，返回给迭代器条件判断，然后吧每次遍历的地址值给了这个对象名   System.out.println(dem.geting()); }}class Demo2{   private Stirng ing;   private int in;   public Demo2(){}   public Demo2(String ing,int in){   this.ing = ing;   this.in = in;   }   public String geting(){     return ing;   }   public void seting(String ing){    this.ing = ing;   }   public int getin(int in){    return in;   }   public void setin(int in){   this.in = in;   } 

---

---

---

---

---

---

---

---

---

Collecton接口子类List

List接口：特有的常见方法，有一个共性特点就是都可以操作角标

Vector：内部是数组数据结构，是同步的。增删，查询很慢。

ArrayList：内部是数组数据结构，是不同步的，替代了Vector。查找元素很快，删除其中，则坐标移动，一动则动全身，因为他储存方式是数组，增删，其动全部坐标，删除也是。

LinkedList：内部是链表数据结构，是不同步的，增删元素的速度很快

以下是常见方法区

1. 添加：

void add(index,element);

void add(index,collecton);

2.删除：

Object remove(index);

3.修改：

Object set(index,element);

4.获取：

Object get(index);

int indexOf(object);

int lastIndexOf(object);

List subList(fron,to);

---

增加元素：void add(index,collecton):获取元素的角标，来添加元素

语法如下：

class Demo{ public static void main(String[]args){ List list = new ArrayList();        yi(list);//调用他的引用   } public static void yi(List list){//获取List 的list对象名   list.add("abc1");   list.add("abc2");   list.add("abc3");       list.add(1,"abc5");  //这句话就是在集合1角标哪里直接插入    }  } 

---

删除元素： Object remove(index)：在remove()参数括号里面填写哪个坐标，就删除哪个元素。

语法如下：

 class Demo{publc static void mian(String[]args){  List list = new ArrayList();   yi(list);       }public static void yi(List list){    list.add("abc");    list.add("aaa");    list.add("add");    System.out.println(list.remove(2));  //这句话就是用List调用自身的方法，remove删除坐标2的元素。    } } 

---

修改元素：Object set(index,”asdf”);在指定坐标，修改元素

语法如下：

 class Demo{    public static void main（String[]args){     List list = new ArrayList();        yi(list);    }     public static void yi(List list){       list.add("a");       list.add("b");       list.add("c");       System.out.println(list.set(1,"ha"))  //吧指定坐标的元素修改成当前元素。     }    } 

get(int index)：这种方法用于返回列表中指定位置的元素。

语法如下：

 class Demo{     public static void main(String[]args){     Collecetion colleciotn = new ArrayList();     collection.add(new Demo1("哈哈",123));     collection.add(new Demo1("我是",11));     System.out.println(collection.size());     for(int i = 0;i<collection.size();i++){      List list = (List)collection;       Demo1 demo  =(Demo1) list.get(i);       //为什么要用List了？因为只有List是colleection的子类，但是List这个接口有get方法，用来获取元素              }           }      }      class Demo1{      private String ing ;      private int in;      Demo1(){}      Demo1(Stirng ing,int in){      this.ing = ing;      this.in = in;      }      public String geting(){      return ing;      }      public void seting (String ing){      this.ing = ing;      }      public int getin(){      return in;      }      public void setin(int in){      this.in = in;      }    } 

---

---

---

---

---

---

LinkedList();类 来自List接口。

addFirst()方法：　　　　　用于来逆序集合的元素

增加头部元素：

 //此段代码不能执行！只为参考不常用的方法！class Demo{ public static void main(String[]args){ LinkedList linkedlinst = new LinkedLint();  yi(linkedlist);    }  public static void yi(LinkedList linkedlist){   linkedlist.addFirst("1");   linkedlist.addFirst("2");   linkedlist.addFirst("3");   linkedlist.addFirst("4");   //删除迭代器的头一个元素，remove是删除，First是头部  System.out.println(removeFirst);  //这句代码是 删除头部。  //get是获取元素，System.out.println(getFirst()); //获取几个第一个元素 //因为都是collection的接口的子类，我们用LinkedList调用collection迭代器      Iterator It = linkedlist.iterator();     while(It.hasNext()){      System.out.println(It.next());      }    } } 

Collection接口子类：

set接口：元素不可重复，是无序的。继承了collection接口，因此拥有collection方法。

set接口有两个子类比较常用。HashSet，TreeSet。

Hashset；内部数据结构是哈希表，是不同步的：此类实现set接口，它不保证set的迭代顺序，特别是他不保证该顺序恒久不变，此类允许使用null元素。所以存储元素的时候，使用的元素的hashCode方法来确定位置，如果位置相同，在通过元素的equals来确定是否相同　　　　　　储存方式就是:　　用hashcode方法确定元素的地址，然后在用equals判断元素的内容

HashSet类：

HashSet方法：

 class Demo{public static void main(string[]args){   HashSet hashset = new HashSet();  hashset.add("1");  hashset.add("2");  hashset.add("3");  hashset.add("4");    Iterator It = hashset.iterator();  while(It.hasHext()){    System.out.println(It.next());     }   }}  //打印出来不保证迭代顺序，如果有重复元素，只打印一个  //因为HashSet类是根据哈希算法的元素来存储的。用于查找速度快。不能重复元素，是因为他根据算法来储存的，所以直接覆盖了当前的相同的元素。 

LinedHashSet方法：

 class Demo{ public static void main(String[]args){  HashSet linkedHashSet = new LinkedHashSet();    linkedHashSet.add("1");    linkedHashSet.add("2");    linkedHashSet.add("3");    linkedHashSet.add("1");    linkedHashSet.add("2");    Iterator It = linkedHashSet.iterator();    while(It.hasNext()){        System.out.println(It.next(););          }     } }//LinkedHashSet();方法是元素有序，只唯一。因为他是哈希列表，链接列表实现。 

---

TreeSet：可以对Set集合中的元素进行排序，是不同步的。

基本语法如下：

 public class tersetDemo { public static void main(String[]args){     TreeSet treeset  =new TreeSet();     treeset.add(new Demo("嘻嘻",19));     treeset.add(new Demo("哈哈",12));     treeset.add(new Demo("啦啦",42));     treeset.add(new Demo("呵呵",49));     treeset.add(new Demo("突突",13));     for(Iterator It = treeset.iterator();It.hasNext();){      System.out.println(It.next());          }      } }class Demo{private String name;private int in;Demo(){}Demo(String name,int in){    this.name = name;    this.in = in;}public String getName() {    return name;}public void setName(String name) {    this.name = name;}public int getIn() {    return in;}public void setIn(int in) {    this.in = in;  }} //这段代码会报异常：   Exception in thread "main" java.lang.ClassCastException: Demo1.Demo cannot be cast to java.lang.Comparableat java.util.TreeMap.put(TreeMap.java:542)at java.util.TreeSet.add(TreeSet.java:238)at Demo1.tersetDemo.main(tersetDemo.java:8) 

---

---

---

---

---

---

---

---

---

---

---

---

---

---

TreeSet

1，元素不可重复

2，可以按照自然顺序排序

3，如果排序的是引用数据类型，需要实现Comparable接口

此接口需要重写compareTo()方法，此方法规定，如果该对象小于，等于或大于指定对象，则分别返回负整数，零或正整数。

正确的TreeSet方法： 数字排序

class Demo{public static void main(String[]args){  set set =new TreeSet();  set.add(new Demo1("张三",12));  set.add(new Demo1("李四",11));  set.add(new Demo1("王麻子",213));  for(Iterator It = set.iterator();It.hasNext()){    Demo1 demo = (Demo1)It.next();  System.out.println(demo.getname());       } } class Demo1 implements Comparable{         //实现Comparable接口,调用接口的compareTo方法； private String name; private int in; Demo1(){ } Demo1(String name,int in){ this.name = name; this.in = in; } public String getName(){   return name; } public void setnName(String name){   this.name = name; } public int getIn(){   return in; } public void setIn(int in){   this.in = in; } //需要重写Object的toString方法;  public String toString(){    return name +"；"+ in; } //调用接口的方法 public int compareTo(Object o)   Demo1 demo = (Demo1)o;   if(this.in>demo.in){      return 1;   }if (this.in<demo.in){      return -1;   }else{      return 0;   }  //这样就是排序他的数字属性这个。} 

如果全部返回的是1，那么按顺排序。

 public int compareTo(Object o) {   Demo dd =(Demo)o;   if(this.in<dd.in ){      return 1;   }if (this.in>dd.in){      return 1;    }else{       return 1;   } //在方法里面返回的负数和正数来排序的。}} 

字符串排序

 class treesetDemo1{ public static void main(String[]args){  TreeSet treeset =new TreeSet();  treeset.add("星期一");  treeset.add("星期二");     treeset.add("星期三");  treeset.add("星期四");  Iterator It = treeset.iterator();    }}class Demo3{ private String name; Demo3(){ } Demo3(String name){  this.name = name; } public String getName(){    return name;}public void setName(String name){    this.name = name;}public String toString (){} } 

---

---

---

---

---

---

---

---

---

---

---

Map：

一次添加一对元素，collection一次添加一个元素。

Map也称为双列结合，collection集合称为单列集合。

其实Map集合中存储的是键值对。Map集合中必须保证键的唯一性。

1，添加

value put(key,value):返回前一个和key关联的值，如果没有返回null 

2，删除

value clear();清空Map集合。value remove(key);根据指定的key翻出这个键值对。 

3，判断

boolean containsKey(key):boolean containsValue(value):boolean isEmpty(); 

4，获取

value get(key);通过建获取值，如果没有该键返回null。当然可以通过返回null，来判断是否包含指定建。int size();获取键值对的个数。 

put方法；

class Demo1{ public static void main(String[]args){ Map map = new HashMap();     map.put("键","值");     map.put("键", "值1");     map.put("活动钱包","不好" );     map.put("活动钱包","不好");     map.put("呵呵", "哈哈");//如果键相同，那么第一个不打印，键和值相同，不重复。 是无序的     }} 

Map集合和Collection集合不一样，所以Map集合里面没有迭代器方法 。

---

取出Map中的所有元素。　　　原理，通过keySet方法获取map中所有的键所在的set集合，再通过set的迭代器获取到每一个键，在对每一个键获取对应的的值即可。

 class HashMap{  public static void main(String[]args){  HashMap hash = new HashMap();  hash.put("1","一");  hash.put("2","二");  hash.put("3","三");  //获取到键遍历：  Set set = map.keySet(); //因为HashMap的接口是Set； //通过键拿到值遍历 for(Iterator It = set.iterator();It.hasNext();){      Object obj = It.next();   //吧键给这个obj  System.out.println(obj+""+map.get(obj));   //obj的值   为什么需要get了？ get是获取到当前的值  } }        } 

存键打值 Map对象名.get(键)；

 import java.util.HashMap; import java.util.Iterator; import java.util.Set; public class HashMapDemo3 { public static void main(String[]args){   HashMap<String,Student> map = new HashMap<String ,Student>();   Student set = new Student("李明","男");   map.put("Jack",set);    boolean  b  = map.containsKey("Jack");   //判断这个map集合是否存在这个键。    Set<String> s = map.keySet(); //map没有迭代器方法，set有，吧字符串的键，转成set集合里面，    if(b){   for( Iterator<String> it = s.iterator();it.hasNext();){    String ing =  it.next();    Student stu = map.get(ing);    System.out.println("Jack对应的学院姓名是："+stu.getName()+"：性别是"+stu.getSex());                 }           }     } }class Student{private String name;private String sex;Student(){}Student(String name,String sex){     this.name = name;     this.sex = sex;}public String getName() {    return name;}public void setName(String name) {    this.name = name;}public String getSex() {    return sex;}public void setSex(String sex) {    this.sex = sex;}} 

Collections类常用方法：

Collections和Collection不同，前者是集合的操作类，后者是集合接口!

Collections提供的常用静态方法：

sort(): 排序

 import java.util.ArrayList;   import java.util.Collections;   import java.util.Iterator;   public class CollectionMinDemo {   public static void main(String[]args){   ArrayList list = new ArrayList();   list.add(new Student1("指尖",12));   list.add(new Student1("跳动",23));   list.add(new Student1("安全",12));   list.add(new Student1("异常",314));   list.add(new Student1("阿斯顿",123));   Collections.sort(list);    //在这里就是 系统就要给这些的值进行排序，然后我们在遍历即可！   for(Iterator It =  list.iterator();It.hasNext();){       Object obj = It.next();       Student1 stu = (Student1)obj;       System.out.println("姓名："+stu.getName()+":"+stu.getAge());  //           System.out.println(list);   }  //       System.out.println(list);  }}class Student1 implements Comparable<Student1>{private String name;private int age;Student1(){}Student1(String name,int age){    this.name = name;    this.age = age;}public String getName() {    return name;}public void setName(String name) {    this.name = name;}public int getAge() {    return age;}public void setAge(int age) {    this.age = age;}@Overridepublic int compareTo(Student1 o) {  int num = this.age - o.age;    return num;//比较他们两个差值，然后返回给这个属性类，然后系统进行排序。}} 

小练习2：

 import java.util.ArrayList;  import java.util.Collections;  import java.util.Iterator;  public class CollectionsDemo3 {  public static void main(String[]args){   ArrayList<Student> arr = new ArrayList<Student>();   arr.add(new Student("北京大学","北京",100,7));   arr.add(new Student("复旦大学","上海",82,7));   arr.add(new Student("北京大学","北京",98,7));   arr.add(new Student("浙江大学","浙江",82,5));   arr.add(new Student("武汉大学","湖北",82,6));   arr.add(new Student("中山大学","广东",76,4));   arr.add(new Student("国防科技大学","湖南",80,4));   arr.add(new Student("南京大学","江苏",80,5));   arr.add(new Student("上海交通大学","上海",81,4));   arr.add(new Student("中国人民大学","上海",42,1));   Collections.sort(arr);//      System.out.println("");   for(Iterator<Student> It = arr.iterator();It.hasNext();){          Student stu = It.next();     System.out.println(stu.getName()+"\t"+stu.getDiqu()+"\t"+stu.getAge()+"\t"+stu.getIn());   }  }  }class Student implements Comparable<Student>{private String name;private String Diqu;private int age;private int in;Student(){}Student(String name,String Diqu,int age ,int in){    this.name = name;    this.Diqu = Diqu;    this.age = age;    this.in = in;}public String getName() {    return name;}public void setName(String name) {    this.name = name;}public String getDiqu() {    return Diqu;}public void setDiqu(String diqu) {    Diqu = diqu;}public int getAge() {    return age;}public void setAge(int age) {    this.age = age;}public int getIn() {    return in;}public void setIn(int in) {    this.in = in;}@Overridepublic int compareTo(Student o) { int num = this.age - o.age; int num2 = num == 0?this.in-o.in:num;    return num2; /*比较总分，的同时，如果发现等于0 ，那么总分必定一样，在这种的情况下。     就比较他的星级，返回他的差！如果不能与0 就返回num！他的总分!!!! */ }   }