//------------集合------------------------------------------



//------------集合------------------------------------------

 

 

 

import java.util.*;

 

/*

Collection定义了集合框架的共性功能。

1，添加

      add(e);

      addAll(collection);

 

2，删除

      remove(e);

      removeAll(collection);

      clear();

 

3，判断。

      contains(e);

      isEmpty();

 

4，获取

      iterator();

      size();

 

5，获取交集。

      retainAll();

 

6，集合变数组。

      toArray();

 

 

 

1，add方法的参数类型是Object。以便于接收任意类型对象。

 

2，集合中存储的都是对象的引用(地址)

 

 

什么是迭代器呢？

其实就是集合的取出元素的方式。

如同抓娃娃游戏机中的夹子。

 

迭代器是取出方式，会直接访问集合中的元素。

所以将迭代器通过内部类的形式来进行描述。

通过容器的iterator()方法获取该内部类的对象。

 

 

 

 

*/

class CollectionDemo

{

      publicstatic void main(String[] args)

      {

             

             method_get();

      }

      publicstatic void method_get()

      {

             ArrayListal = new ArrayList();

 

             //1，添加元素。

             al.add("java01");//add(Objectobj);

             al.add("java02");

             al.add("java03");

             al.add("java04");

 

             /*

             Iteratorit = al.iterator();//获取迭代器，用于取出集合中的元素。

 

             while(it.hasNext())

             {

                    sop(it.next());

             }

             */

 

             for(Iteratorit = al.iterator(); it.hasNext() ; )

             {

                    sop(it.next());

             }

      }

 

 

      publicstatic void method_2()

      {

             ArrayListal1 = new ArrayList();

 

             al1.add("java01");

             al1.add("java02");

             al1.add("java03");

             al1.add("java04");

             ArrayListal2 = new ArrayList();

 

             al2.add("java03");

             al2.add("java04");

             al2.add("java05");

             al2.add("java06");

 

             

             //al1.retainAll(al2);//去交集，al1中只会保留和al2中相同的元素。

             al1.removeAll(al2);

 

             sop("al1:"+al1);

             sop("al2:"+al2);

 

 

 

 

      }

 

      publicstatic void base_method()

      {

             //创建一个集合容器。使用Collection接口的子类。ArrayList

             ArrayListal = new ArrayList();

 

             //1，添加元素。

             al.add("java01");//add(Objectobj);

             al.add("java02");

             al.add("java03");

             al.add("java04");

 

             //打印原集合。

             sop("原集合:"+al);

 

 

             //3，删除元素。

             //al.remove("java02");

             //al.clear();//清空集合。

 

 

             //4，判断元素。

             sop("java03是否存在:"+al.contains("java03"));

             sop("集合是否为空？"+al.isEmpty());

 

 

             //2，获取个数。集合长度。

             sop("size:"+al.size());

 

             //打印改变后的集合。

             sop(al);

 

      }

 

      publicstatic void sop(Object obj)

      {

             System.out.println(obj);

      }

}

 

//--------------------------------------

/*

Collection

      |--List:元素是有序的，元素可以重复。因为该集合体系有索引。

             |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。 //非线性数组.

             |--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。//线性数组.

 

             |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。

//非线性数组.

 

 

      |--Set：元素是无序，元素不可以重复。、

 

 

LinkedList

List：

      特有方法。凡是可以操作角标的方法都是该体系特有的方法。

 

增

      add(index,element);

      addAll(index,Collection);

 

删

      remove(index);

 

改

      set(index,element);

查

      get(index):

      subList(from,to);

      listIterator();

      intindexOf(obj):获取指定元素的位置。

      ListIteratorlistIterator();

 

List集合特有的迭代器。ListIterator是Iterator的子接口。

 

在迭代时，不可以通过集合对象的方法操作集合中的元素。

因为会发生ConcurrentModificationException异常。

 

所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，

只能对元素进行判断，取出，删除的操作，

如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。

 

该接口只能通过List集合的listIterator方法获取。

 

//----------------------vector---------------

 

import java.util.*;

 

/*

枚举就是Vector特有的取出方式。

发现枚举和迭代器很像。

其实枚举和迭代是一样的。

 

因为枚举的名称以及方法的名称都过长。

所以被迭代器取代了。

枚举郁郁而终了。

 

 

 

*/

class VectorDemo

{

      publicstatic void main(String[] args)

      {

             Vectorv = new Vector();

 

             v.add("java01");

             v.add("java02");

             v.add("java03");

             v.add("java04");

 

             Enumerationen = v.elements();

 

             while(en.hasMoreElements())

             {

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

             }

      }

}

 

//-----------------------------

/*

使用LinkedList模拟一个堆栈或者队列数据结构。

 

堆栈：先进后出 如同一个杯子。

队列：先进先出 Firstin First out FIFO 如同一个水管。

 

 

 

*/

 

import java.util.*;

class DuiLie

{

      privateLinkedList link;

 

      DuiLie()

      {

             link= new LinkedList();

      }

      

      publicvoid myAdd(Object obj)

      {

             link.addFirst(obj);

      }

      publicObject myGet()

      {

             returnlink.removeFirst();

      }

      publicboolean isNull()

      {

             returnlink.isEmpty();

      }

 

}

 

 

 

class LinkedListTest

{

      publicstatic void main(String[] args)

      {

             DuiLiedl = new DuiLie();

             dl.myAdd("java01");

             dl.myAdd("java02");

             dl.myAdd("java03");

             dl.myAdd("java04");

 

             while(!dl.isNull())

             {

                    System.out.println(dl.myGet());

             }

      }

}

//--------------------

class TreeSetDemo

{

      publicstatic void main(String[] args)

      {

             TreeSetts = new TreeSet();

//TreeSet ts=new TreeSet(new MyCompare());

             ts.add(newStudent("lisi02",22));

             ts.add(newStudent("lisi007",20));

             ts.add(newStudent("lisi09",19));

             ts.add(newStudent("lisi08",19));

             //ts.add(newStudent("lisi007",20));

             //ts.add(newStudent("lisi01",40));

 

             Iteratorit = ts.iterator();

             while(it.hasNext())

             {

                    Studentstu = (Student)it.next();

                    System.out.println(stu.getName()+"..."+stu.getAge());

             }

      }

}

 

 

class Student implements Comparable//该接口强制让学生具备比较性。

{

      privateString name;

      privateint age;

 

      Student(Stringname,int age)

      {

             this.name= name;

             this.age= age;

      }

 

      publicint compareTo(Object obj)

      {

 

             //return0;

             

             if(!(objinstanceof Student))

                    thrownew RuntimeException("不是学生对象");

             Students = (Student)obj;

 

             System.out.println(this.name+"....compareto....."+s.name);

             if(this.age>s.age)

                    return1;

             if(this.age==s.age)

             {

                    returnthis.name.compareTo(s.name);

             }

             return-1;

             /**/

      }

 

      publicString getName()

      {

             returnname;

 

      }

      publicint getAge()

      {

             returnage;

      }

}

 

//------------------------------------

class Student implements Comparable//该接口强制让学生具备比较性。

{

      privateString name;

      privateint age;

 

      Student(Stringname,int age)

      {

             this.name= name;

             this.age= age;

      }

 

      publicint compareTo(Object obj)

      {

 

             //return0;

             

             if(!(objinstanceof Student))

                    thrownew RuntimeException("不是学生对象");

             Students = (Student)obj;

 

             System.out.println(this.name+"....compareto....."+s.name);

             if(this.age>s.age)

                    return1;

             if(this.age==s.age)

             {

                    returnthis.name.compareTo(s.name);

             }

             return-1;

             /**/

      }

 

      publicString getName()

      {

             returnname;

 

      }

      publicint getAge()

      {

             returnage;

      }

}

//-----------------comparetor2------------------------

需求：

往TreeSet集合中存储自定义对象学生。

想按照学生的年龄进行排序。

 

 

记住，排序时，当主要条件相同时，一定判断一下次要条件。

 

 

*/

 

 

import java.util.*;

 

/*

当元素自身不具备比较性，或者具备的比较性不是所需要的。

这时需要让容器自身具备比较性。

定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

 

当两种排序都存在时，以比较器为主。

 

定义一个类，实现Comparator接口，覆盖compare方法。

 

 

*/

class Student implements Comparable//该接口强制让学生具备比较性。

{

      privateString name;

      privateint age;

 

      Student(Stringname,int age)

      {

             this.name= name;

             this.age= age;

      }

 

      publicint compareTo(Object obj)

      {

 

             //return0;

             

             if(!(objinstanceof Student))

                    thrownew RuntimeException("不是学生对象");

             Students = (Student)obj;

 

             //System.out.println(this.name+"....compareto....."+s.name);

             if(this.age>s.age)

                    return1;

             if(this.age==s.age)

             {

                    returnthis.name.compareTo(s.name);

             }

             return-1;

             /**/

      }

 

      publicString getName()

      {

             returnname;

 

      }

      publicint getAge()

      {

             returnage;

      }

}

class TreeSetDemo2

{

      publicstatic void main(String[] args)

      {

             TreeSetts = new TreeSet();

               //TreeSet ts=new TreeSet(newMyCompare());

             ts.add(newStudent("lisi02",22));

             ts.add(newStudent("lisi02",21));

             ts.add(newStudent("lisi007",20));

             ts.add(newStudent("lisi09",19));

             ts.add(newStudent("lisi06",18));

             ts.add(newStudent("lisi06",18));

             ts.add(newStudent("lisi007",29));

             //ts.add(newStudent("lisi007",20));

             //ts.add(newStudent("lisi01",40));

 

             Iteratorit = ts.iterator();

             while(it.hasNext())

             {

                    Studentstu = (Student)it.next();

                    System.out.println(stu.getName()+"..."+stu.getAge());

             }

      }

}

 

 

class MyCompare implements Comparator

{

      publicint compare(Object o1,Object o2)

      {

             Students1 = (Student)o1;

             Students2 = (Student)o2;

 

             intnum = s1.getName().compareTo(s2.getName());

             if(num==0)

             {

 

                    returnnew Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));

                    /*

                    if(s1.getAge()>s2.getAge())

                           return1;

                    if(s1.getAge()==s2.getAge())

                           return0;

                    return-1;

                    */

             }

             returnnum;

      }}

//------------

/*

/*

练习：按照字符串长度排序。

 

字符串本身具备比较性。但是它的比较方式不是所需要的。

 

这时就只能使用比较器。

 

import java.util.*;

 

/*

当元素自身不具备比较性，或者具备的比较性不是所需要的。

这时需要让容器自身具备比较性。

定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

 

当两种排序都存在时，以比较器为主。

 

定义一个类，实现Comparator接口，覆盖compare方法。

 

 

*/

class Student implements Comparable//该接口强制让学生具备比较性。

{

      privateString name;

      privateint age;

 

      Student(Stringname,int age)

      {

             this.name= name;

             this.age= age;

      }

 

      publicint compareTo(Object obj)

      {

 

             //return0;

             

             if(!(objinstanceof Student))

                    thrownew RuntimeException("不是学生对象");

             Students = (Student)obj;

 

             //System.out.println(this.name+"....compareto....."+s.name);

             if(this.age>s.age)

                    return1;

             if(this.age==s.age)

             {

                    returnthis.name.compareTo(s.name);

             }

             return-1;

             /**/

      }

 

      publicString getName()

      {

             returnname;

 

      }

      publicint getAge()

      {

             returnage;

      }

}

class TreeSetDemo2

{

      publicstatic void main(String[] args)

      {

             TreeSetts = new TreeSet();

               //TreeSet ts=new TreeSet(newMyCompare());

             ts.add(newStudent("lisi02",22));

             ts.add(newStudent("lisi02",21));

             ts.add(newStudent("lisi007",20));

             ts.add(newStudent("lisi09",19));

             ts.add(newStudent("lisi06",18));

             ts.add(newStudent("lisi06",18));

             ts.add(newStudent("lisi007",29));

             //ts.add(newStudent("lisi007",20));

             //ts.add(newStudent("lisi01",40));

 

             Iteratorit = ts.iterator();

             while(it.hasNext())

             {

                    Studentstu = (Student)it.next();

                    System.out.println(stu.getName()+"..."+stu.getAge());

             }

      }

}

 

 

class MyCompare implements Comparator

{

      publicint compare(Object o1,Object o2)

      {

             Students1 = (Student)o1;

             Students2 = (Student)o2;

 

             intnum = s1.getName().compareTo(s2.getName());

             if(num==0)

             {

 

                    returnnew Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));

                    /*

                    if(s1.getAge()>s2.getAge())

                           return1;

                    if(s1.getAge()==s2.getAge())

                           return0;

                    return-1;

                    */

             }

 

             

             returnnum;

 

      }

}

 

 

//---------------------------------------------------------

 

import java.util.*;

class TreeSetTest

{

      publicstatic void main(String[] args)

      {

             TreeSetts = new TreeSet(new StrLenComparator());

 

             ts.add("abcd");

             ts.add("cc");

             ts.add("cba");

             ts.add("aaa");

             ts.add("z");

             ts.add("hahaha");

 

             Iteratorit = ts.iterator();

 

             while(it.hasNext())

             {

                    System.out.println(it.next());

             }

      }

}

 

class StrLenComparator implementsComparator

{

      publicint compare(Object o1,Object o2)

      {

             Strings1 = (String)o1;

             Strings2 = (String)o2;

 

             /*

             if(s1.length()>s2.length())

                    return1;

             if(s1.length()==s2.length())

                    return0;

                    */

 

                    

 

             intnum = new Integer(s1.length()).compareTo(new Integer(s2.length()));

             if(num==0)

                    returns1.compareTo(s2);

 

             returnnum;

      }

}

 

//--------------------------黑马程序员_毕向东_Java基础视频教程第15天-12-集合框架(泛型限定)-------------------------

class GenericDemo6

{

      publicstatic void main(String[] args)

      {

             /*

             ArrayList<String>al = new ArrayList<String>();

 

             al.add("abc1");

             al.add("abc2");

             al.add("abc3");

 

             ArrayList<Integer>al1 = new ArrayList<Integer>();

             al1.add(4);

             al1.add(7);

             al1.add(1);

 

             printColl(al);

             printColl(al1);

             */

 

             ArrayList<Person>al = new ArrayList<Person>();

             al.add(newPerson("abc1"));

             al.add(newPerson("abc2"));

             al.add(newPerson("abc3"));

             //printColl(al);

 

             ArrayList<Student>al1 = new ArrayList<Student>();

             al1.add(newStudent("abc--1"));

             al1.add(newStudent("abc--2"));

             al1.add(newStudent("abc--3"));

             printColl(al1); //ArrayList<? extends Person> al = newArrayList<Student>();error

 

      }

      publicstatic void printColl(Collection<? extends Person> al)

      {

             Iterator<?extends Person> it = al.iterator();

 

 

             while(it.hasNext())

             {

                    System.out.println(it.next().getName());

             }

      }

      /*

      publicstatic void printColl(ArrayList<?> al)//ArrayList al = newArrayList<Integer>();error

      {

             Iterator<?>it = al.iterator();

 

 

             while(it.hasNext())

             {

                    System.out.println(it.next().toString());

             }

      }

      */

}

 

class Person

{

      privateString name;

      Person(Stringname)

      {

             this.name= name;

      }

      publicString getName()

      {

             returnname;

      }

}

 

class Student extends Person

{

      Student(Stringname)

      {

             super(name);

      }

 

}

 

 

/*

 

class Student implementsComparable<Person>//<? super E>

{

      publicint compareTo(Person s)

      {

             this.getName()

      }

}

*/

class Comp implementsComparator<Person>

{

      publicint compare(Person s1,Person s2)

      {

 

             //Persons1 = new Student("abc1");

             returns1.getName().compareTo(s2.getName());

      }

}

 

TreeSet<Student> ts = new TreeSet<Student>(newComp());

ts.add(new Student("abc1"));

ts.add(new Student("abc2"));

ts.add(new Student("abc3"));

 

 

//--------------------------

import java.util.*;

class GenericDemo7

{

      publicstatic void main(String[] args)

      {

             

             TreeSet<Student>ts = new TreeSet<Student>(new Comp());

 

             ts.add(newStudent("abc03"));

             ts.add(newStudent("abc02"));

             ts.add(newStudent("abc06"));

             ts.add(newStudent("abc01"));

             

             Iterator<Student>it = ts.iterator();

 

             while(it.hasNext())

             {

                    System.out.println(it.next().getName());

             }

             /**/

 

 

 

             TreeSet<Worker>ts1 = new TreeSet<Worker>(new Comp());

 

             ts1.add(newWorker("wabc--03"));

             ts1.add(newWorker("wabc--02"));

             ts1.add(newWorker("wabc--06"));

             ts1.add(newWorker("wabc--01"));

 

 

             Iterator<Worker>it1 = ts1.iterator();

 

             while(it1.hasNext())

             {

                    System.out.println(it1.next().getName());

             }

      }

}

 

/*

class StuComp implementsComparator<Student>

{

      publicint compare(Student s1,Student s2)

      {

             returns1.getName().compareTo(s2.getName());

      }

}

 

class WorkerComp implementsComparator<Worker>

{

      publicint compare(Worker s1,Worker s2)

      {

             returns1.getName().compareTo(s2.getName());

      }

}

*/

 

class Comp implementsComparator<Person>

{

      publicint compare(Person p1,Person p2)

      {

             returnp2.getName().compareTo(p1.getName());

      }

}

 

 

class Person

{

      privateString name;

      Person(Stringname)

      {

             this.name= name;

      }

      publicString getName()

      {

             returnname;

      }

      publicString toString()

      {

             return"person :"+name;

      }

}

 

class Student extends Person

{

      Student(Stringname)

      {

             super(name);

      }

 

}

 

class Worker extends Person

{

      Worker(Stringname)

      {

             super(name);

      }

}