集合

集合：
    动态的存储多个对象
1、为什么出现集合类？
       面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是对象最常用的一种方式。
2、数组和集合类同是容器，有何不同？
       数组虽然可以存储对象，但长度是固定的，集合长度是改变的
       数组中可以存储基本数据类型，集合只能存储对象
       问题：数组中怎么存储对象？直接创建自定义类型的数组，存放数据就行
3、集合类的特点
       集合只用于存储对象，
       集合长度是可变的，
       集合可以存储不同类型的对象
4、为什么会出现这么多的容器呢？
       因为每一个容器对数据的存储方式都有不同。
       这个存储方式称之为：数据结构
       Person p  = new Person();
       ArrayList    a  =  new ArrayList();
       a.add(p);
       
      Collection  c=new  ArrayList（）；
      c.add( 'a' );//只能添加对象Object类型的，这里其实是经过了一个转型char ====》                  Character====》Object
      c.add(500);//int===>Integer===>Object
      注意：add和addAll方法在和中添加集合的区别；
                  add------->集合添加数据，每add一次添加一个
 addAll------->集合中添加集合，长度就是两个集合长度的和
 size------->计算集合中元素的个数（或者集合的长度）
 contains----->判断集合中是否有此对象，但是是根据equals方法判断
 clear------->清空集合中的所有元素
 toArray----->把一个集合转成一个Object类型的数组
 containsAll----->当前集合如果包含了另一个集合中的所有元素，则返回true，反之                                   false
                  hashCode是十进制值
 retainAll：取交集，但是变化的当前调用方法的对象
5、(1)add方法中的参数类型是Object。以便于接收任意类型对象
      (2)集合中存储的都是对象的引用(地址)
6、常用方法
       remove（"删除指定元素"） clear（）；清空集合  contains判断元素是否存在
       retainAll：在两个集合中去交集  a1.removeAll（a2）；把a1中和a2相同的元素去除掉
7、迭代器
      直接打印对象局限性很大，不能对集合中的具体数据进行操作，所以需要遍历集合
      Iterator it = 集合对象.iterator;
      while(it.hasNext()){
          System.out.println(it.next());
      }
      第二种方式：
      for（Iterator it =coll.iterator();it.hasNext(); ）{
       System.out.println(it.next());
      }
      什么是迭代器？其实就是元素取出的方式
      迭代器（类）定义在集合的内部：因为元素在集合中，想直接操作集合中的元素，所以在集合内部       操作最方便，这样取出方式就可以直接访问集合内部的元素，那么取出方式就定义成了内部类
       而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都有共性内容 就是判断和取        出。那么可以将这些共性内容抽取，形成了接口（Iterator）；
      那么这些内部类都符合一个规则。该规则就是Iterator
      
      该对象必须依赖于具体容器，因为每一个容器的数据结构都不同
      所以该迭代器对象是在容器中进行内部实现的
      对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，也就      是iterator方法


      如何获取集合的取出对象呢？
      通过一个对外提供的方法iterator( );
      remove方法：it.remove( )
      如果没加判断，删除游标左边的元素：
      如果加了判断，就移除判断的元素


       注意：在迭代过程中，不要使用集合操作元素，容易出现异常
             可以使用Iterator的子接口ListIterator来完成在迭代中对元素进行更多的操作
             它可以实现在迭代过程中完成对元素的增删改查，但只有List集合具备这个迭代功能
             并且ListIterator还有一个hasPrevious方法，是否有前一个元素，可以逆向遍历列表
--------------------------------------------------------------------------------------------
8、List：
       |----vector:内部是数组数据结构，是同步的，增删，查询都很慢
       |----ArrayList：内部是数组数据结构，是不同步的（替代了Vector）查询的速度快，增删慢（                      你可能会问多线程时用哪个，我们一般也用ArrayList，我们通过加锁来完成）
       |----LinkedList：内部是链表数据结构，是不同步的，增删元素的速度很快（一般除了Vector都                       是不同步的因为效率高）双向链表
       什么是枚举？
       Iterator的出现替代了Enumeration，因为枚举的名称和方法名太长
       (1)List和Set的区别：
          List：有顺序可以重复
          Set：无顺序不可以重复
       (2)null和isEmpty的区别？
          null----》没有生成集合对象
          empty-----》有集合但是集合中没有元素
9、栈和队列
   面试题：请使用LinkedList来模拟一个栈或者队列数据结构
   栈：先进后出，后进先出
   队列：先进先出，后进后出
   //描述一个容器，提供一个容器对象完成这两种结构中的一种
   描述队列：
   class Duilie{
    private LinkedList link;
    public Duilie(){
        link = new LinkedList();
    }
    public void myAdd(Object obj){
        link.addLast();
    }
    public Object myRemove(){
        return link.removeFirst();
    }
    public void isNull(){
        link.isEmpty();
    }
   }
   描述堆栈与队列类似，就是调用LinkedList方法上有所不同
   例子:公司大巴车；喝酒（啤酒、红酒、白酒）喝多了要上厕所就是队列，吐出来就是堆栈
   LinkedList：
   addFist();添加到集合的第一个位置
   addLast();添加到集合的最后一个位置
   jdk1.6
   offerFirst();
   offerLast();


   getFist();获取但不移除，如果链表为空，抛出异常NoSuchElement
   getLast();
   jdk1.6
   peekFist();获取但不移除，如果链表为空，返回null(意味着可以做判断)
   peekLast();


   removeFirst();获取并移除，如果链表为空，抛出异常
   removeLast();
   jdk1.6
   pollFirst();获取并移除，如果链表为空，返回null
   pollLast();
  二、ArrayList：
        是使用数组结构实现的list集合
    1、优点：
    2、常用方法：
       get----------->得到对应位置上的元素值
       set------------>替换某位置上的元素，返回的被替换的那个元素
       add(int a; E element);------>向指定坐标插入指定的元素
       remove(int a,E element);--->删除指定坐标上的元素，返回删除的元素
       indexOf(Object o);------------>找到指定元素在当前列表中的索引
       subList();------------------------->截取集合中的指定区域内的元素，包头不包尾，小心区域     别异常
-------------------------------------------------------------------------------------------
10、Set:
    元素不可以重复，是无序的
    set接口中的方法和collection一致
    |------HashSet：内部数据结构是哈希表，是不同步的(是根据一个算法，对元素进行运算，并获取其                    位置)
          |----LinkedHashSet既有序又可以保证数据的唯一(底层使用双向链表来保证集合中存储的对象                           ，在输出和添加时顺序保一致)
    |------treeSet：底层是二叉树原理
                 (存取一致我们称之为有序)TreeSet的存取不一致所以无序，但是他的特点是可以对                    set集合中的元素进行指定顺序的排序。是不同步的
                    判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元                    素，不存。
                 保证元素不重复，只要指定比较器就可以。
                (1)TreeSet对元素进行排序的方式一：java.lang.Comparable
                   让元素自身具备比较功能，元素就需要实现Comparable接口。覆盖compareTo方法   
                   
                   规律：this和o去比 ：如果从小到大，返回-1，如果从大到小，返回1
                         如果字符串是从大到小，我们就直接return this.compareTo(o.name)*-1;
                (2)TreeSet对元素进行排序的方式二：java.util.Comparator
                   让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法
                   将该类对象作为参数传递给了TreeSet集合的构造函数
                   如何让TreeSet集合中的数据有序？（怎么进的怎么出）：比较器中的返回值设为1。
     哈希表原理：
通过哈希算法将存储的数据（对象）与指定的地址关联
当集合添加新的元素，先调用这个元素的hashCode()方法，此时能定位到存放该元素的物理地址(         哈希码)
     哈希表确定元素是否相同：                
     1、判断的是两个元素的哈希值是否相同
        如果相同，再判断两个对象的内容是否相同
     2、判断哈希值是否相同，其实判断的是对象的hashCode的方法。判断内容相同，用的是equals方法
     注意：如果哈希值不同，是不需要判断equals
      为什么HashCode()方法必须放在Object类中？   
      答：HashCode:在java.lang.Object类中，所有的类都是直接或间接的继承Object，每个对象都有        HashCode（哈希码），所以HashCode()方法必须放在Object类中
     练习：往hashSet集合中存储对象。如果姓名和年龄相同，视为同一个人，视为相同元素（重写           hashCode和equals方法）
     练习：定义功能去除ArrayList中的重复元素
----------------------------------------------------------------------------------------
泛型：
    规定集合中存储对象的类型
    使用在接口或类名之后，例如：List<String> list = new ArrayList<String>();
----------------------------------------------------------------------------------------
Map
存储键值对，验证键不可重复
1、常见方法：
      put(key,value);返回值是与key关联的上一个值，如果没有返回null；
      clear( );清空map集合
      isEmpty( )判断集合是否为空
      containsKey();   containsValue( );返回值为布尔类型
      get(key);根据key获得value值 remove( key);根据键删除键值对，返回值是删除的键值对的值
2、遍历map集合******重点
       (1) 使用keySet获得集合中所有key的集合，根据key获得对应的value
Set<Integer> set1 = map.keySet();
// 遍历Set<Integer>
// foreach
for (Integer i : set1) {
System.out.println(i + "=" + map.get(i));
}
// Iterator
Iterator<Integer> it1 = set1.iterator();
while (it1.hasNext()) {
int key = it1.next();
System.out.println(key + "=" + map.get(key));
}
        (2)使用values返回集合中所有的值
Collection<String> col = map.values();
forEach:   for (String s : col){
             System.out.println(s);}


迭代：Iterator<String> it2 = col.iterator();
             while (it2.hasNext()) {
        System.out.println(it2.next());
               }
(3) 使用entrySet获得集合中的键值对
// Map.Entry<Integer, String>,Map集合中的键值对
Set<Map.Entry<Integer, String>> set2 = map.entrySet();
for (Map.Entry<Integer, String> entry : set2) {
System.out.println(entry.getKey() + "=" + entry.getValue());
}
Iterator<Map.Entry<Integer, String>> it3 = set2.iterator();
while (it3.hasNext()) {
Map.Entry<Integer, String> entry = it3.next();
System.out.println(entry.getKey() + "**" + entry.getValue());
}
3、HashMap，与HashSet类似，为了保证键的不可重复，应该重写hashCode和equals方法
4、xml，json解析，使用集合存储数据
      a：封装成对象，存储到List集合中，List<News>
      b：封装成Map，存储到List集合中，List<Map<String,Object>>
5、TreeMap,与TreeSet类似，键是可以指定顺序的
6、HashTable，存储键值对，类似HashMap
       HashTable，线程是安全的 HashMap线程是不安全的
       hashTable键不可以为null，HashMap键可以为空
7、HashTable使用keys( ) ; 和elements( ) ; 来获取集合中的键和值，得到的都是枚举类型，然后用枚举遍历
注：map还可以用来查表
----------------------------------------------------------------------------------------
8、collections:
      Collections.sort( 集合);对集合进行自然顺序排序  colleactions.sort(集合，比较器)；
      Collections.shuffle(集合);随机按指定顺序排序
       Collections.reverse( );逆序输出
       Collections.copy( ) ;集合的复制 前提：目的地的长度要大于源的长度
 9、properties,属性集
使用步骤：
a：注意文件放置的路径
b：创建属性集
c：加载输入流
d：使用getproties( )读取属性值
集合总结：
1、Collection：每次存储一个对象
      Map：每次存储一对键值对


JDK5.0新特性：函数可变参数
其实就是一个数组，但是接收的是数组中的元素。
自动将这些元素封装成数组。简化了调用者的书写
注意事项：可变参数类型，必须定义在参数列表的结尾
JDK5.0新特性：静态导入
其实导入的是类中的静态成员
例如：工具类在调用静态成员的时候都要写类名，多的时候都要写，例如Collections.sort();如果想直接写sort();方法，在导入包的时候可以这样写import static java.util.Collections.sort;
因为静态成员不需要对象，所以可以直接导入


集合转数组：Collection中的toArray();方法
            可以对集合中的元素操作的方法进行限定。不允许对其进行增删
            List list =new ArrayList(); list.add("aaaa"); 
            String arr[]=list.toArray(new String(list.size())); Sop(Arrays.toStrin(arr));
数组转集合：Arrays里的asList();方法
            好处：可以使用集合中的方法操作数组
            注意：数组的长度的是固定的，所以对于集合的增删方法是不可以使用的
            如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进              行集合存储。
            如果数组中的元素是基本数据类型数值，那么会将该数组作为集合中的元素进行存储


=========================================================================================
properties集合：
特点：
1、该集合中的键和值都是字符串类型
2、集合中的数据可以保存到流中，或者从流读取
通常该集合用于操作以键值对形式存在的配置文件
Properties pro=new Properties();
pro.setProperties("zhangsan","34");
Set<String> names=pro.stringPropertiesNames();
for(String name:names){
   String value=pro.getProperties(name);
   System.out.println(name+"..."+value);
}
store方法：将数据持久化，将数据写到硬盘上
load方法：加载文件到集合


printstream
1、提供了打印方法可以对多种数据类型值进行打印。并保持数据的表示形式
2、他不抛IoException
构造函数：接收三种类型的值
1、字符串路径
2、File对象
3、字节输出流
过滤器如果想要按照指定的扩展名进行过滤的话，在创建构造函数的时候就创建有参数的就可以了