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



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

 

 

 

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);

       }

}