黑马程序员java学习笔记，集合

集合类
  数组只能存储固定长度的，集合是可变的，数组只能存储基本数据类型，集合可以存储对象，长度是不固定的
  java.util package 中
  Collection List Set
  ArrayList LinkedList Vector HashSet TreeSet
 
  ArrayList a1=new ArrayList();
  集合中存放的不是对象实体，只是对象地址
  a1.add("kingkong");
  a1.add("Jack");
  a1.add("Rose");
  a1.add("Sam");
  Iterator it=a1.iterator();
  while(it.hasNext()){  //获取迭代器，用于取出集合中的元素
 it.next();
  }
  或者 用for循环写
   for(Iterator it=a1.iterator();it.hasNext();){
  it.next();
   }
  
   List 中元素是有序的，元素是可以重复的，因为该集合有索引
  ArrayList 底层使用的是数组结构，查询速度很快，但是增删稍慢
  LinkedList 底层使用的是链表数据结构， 增删速度很快，查询稍慢
  Vector 底层是数组结构，线程同步，被ArrayList替代
   Set  中元素是无序的，元素是不可以重复的
-----------------------------------------------------------------------  
   List：特有方法，凡是可以操作角标的都是List的对象
   增
      add(index,element);
   addAll(index,element);
 删
    remove(index);
 改
    set(index,element);
 查
    get(index);
    subList(from,to);
    listIterator();
 for(int x=0;x<a1.size();x++)
 
 ArrayList a1=new ArrayList();
 Iterator it=a1.iterator();
 ListIterator li=a1.ListIterator();//List所特有的迭代器
 
 while(li.hasNext()){
 Object obj=li.next();
 if(obj.equals("kingkong"))
  li.set(obj);
 }
 while(it.hasNext()){
 Object obj=it.next();
 if(obj.equals("kingkong"))
  
  //it.remove();//将kingkong删除
 }
 List 集合的特有的迭代器，ListIterator是Iterator的子接口
  在迭代时，不可以通过集合对象方法操作集合中的元素
  因为会发生ConCurrentModificationException异常
  所以在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的
 ***********************************************************
 LinkedList 中特有的方法
    addFirst();或者offerFirst();
 addLast();或者offerLast();
    getFirst();或者peekFirst();  后面的新方法不会产生异常
 getLast();或者peekLast();
 removeFirst();或者poolFirst();
 removeLast();或者poolLast();
 LinkedList link=new LinkedList();
 link.add("kingkong");
 link.addLast("Jack");
**************************************************************************************************8
Set集合的功能和Collection功能是一样的
  HashSet 底层结构式哈希表，线程是非同步的
    保证元素唯一性的原理，判断hashCode值是否相同
 如果相同，还会继续判断元素的equals方法，是否为true
 HashSet是通过元素的两个方法，hashCode和equals来完成
 如果元素的两个方法，hashCode和equals来完成
 如果元素的HashCode值相同，才会判断equals是否为true
 如果元素的HashCode值不同，不会调用equals
 对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法
  TreeSet 底层结构式二叉树，可以对集合中的元素进行排序
 保证元素唯一性的依据：compareTo方法return 0；
 
  TreeSet排序的第一种方式，让元素具备比较性
  元素要实现Comparable接口，覆盖compareTo方法
 
  TreeSet的第二种排序方式
    当元素不具备比较性，或者具备的比较性不是所需要的
    这时就需要让集合自身具备比较性
    在集合初始化时就有比较性
 
HashSet hs=new HashSet();

hs.add("kingkong");
hs.add("Jack");
hs.add("Rose");
自定义对象 必须复写函数的equals和hashCode
hs.contains(new Person("a1",11));
hs.remove(new Person());
*****************************************************************************
  class Student implements Comparable{
  public int comparaTo(){
   if(!(obj instanceof Student))
    throw new RuntimeException("is not Student instance");
   Student s=(Student)obj;
   if(this.age>s.age)
    return 1;
   if(this.age==s.age){
    return this.name.compareTo(s.name);
   }
   return -1;
    
  }
  }
  TreeSet ts=new TreeSet();
********************************************************************************************
泛型
  用于解决安全问题，是一个安全机制
  ArrayList<String> a1=new ArrayList<String>();
 
  //迭代器也需要泛型表示
  Iterator<String> it=a1.iterator<String>();
 
  1.将运行时期的问题ClassCastException,转移到了编译时期
  2.避免强制转换类型
 
  在使用java提供的对象时，什么时候写泛型
    在集合框架中很常见，只要见到<>就得定义泛型
 <>就是用来接收类型的
 当使用集合时，将集合中要要存储的数据类型作为参数传递到<>中
 当自定义对象，必须定义hashCode和equals方法，还得实现comparable接口，复写其中的compareTo方法，使其具备默认比较性
 TreeSet<Sting> ts=new TreeSet<String>();
 ts.add("kingkong");
    ts.add("Jack"); 
 Iterator<String>it=new Iterator<String>();
    while(it.hasNext()){
  String s=it.next();
 }
 class LenCompatator implements Comparator<String>(){
  public int compare(String s1,String s2){
   int num=new Integer(s1.length()).compateTo(new Integer(s2.length()));
   if(num==0)
    return s2.compareTo(s1);
   return num; 
  }
 }

class Worker{
 
}
class Tool{
 private Object  obj;
 public void setWorker(Object obj){
  this.obj=obj;
 }
 public Object getWorker(){
  return obj;
 }
}
//泛型类 ，当不确定其中的引用顺序不确定，可以定义泛型
class Utils<Type>{
 private Type type;
 public void setObject(Type type){
  this.type=type;
 }
 public Type getObject(){
  return type;
 }
}
/*
class Tool{
 private Worker worker;
 public void setWorker(Worker worker){
  this.worker=worker;
 }
 public Worker getWorker(){
  return worker;
 }
}
**/
静态方法泛型
  class Demo<T>{
 public void show(T t){
  System.out.println(t);
 }
 public <E> void print(E e){
  System.out.println(e);
 }
 //静态方法不可以访问类上定义的泛型
   如果静态方法的操作的应用不确定，可以将泛型定义在方法上
  
   public static <W>void method(W t){
   System.out.println(t);
   }
  }
 泛型定义在接口上
   interface Inter<T>{
  void show(T t);
   }
   class InterImpl extends Inter<String>{
  public void show(String s){
   System.out.println(s);
  }
   }
  class InterImpl<T> implements Iner<T>{
  public void show(T t){
   System.out.println(t);
  }
  }
静态方法不可以访问类上定义的泛型
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上
方法上的泛型标志放在返回值的前面，修饰符的后面
泛型限定
? 是通配符，也可以理解为占位符
<? extends E>可以接受E类型或者E的子类型，上限
<? super E> 可以接受E类型或者E的父类型，下限
public static void printColl(ArrayList<? extends Person>a1){
 Iterator<? extends Person>it=a1.iterator();
}
public static void printColl(ArrayList<？> a1){
 Iterator<?> it=a1.iterator();
 while(it.hasNext()){
  System.out.println(it.next());
 }
}
***************************************************************************************************
Map集合:该集合存储键值对，一对一对的存储
  添加
 put()
 putAll()
  删除
    clear()
 remove()
  判断
 isEmpty()
  获取
 get()
 size()
 values()
 keySet()
 entrySet()
HashTable:底层是哈希表数据结构，线程同步，不可以存入null键null值
       必须实现hashC和equals方法
   
HashMap：哈希表数据结构，允许使用null值和键，不同步
  必须实现hashC和equals方法和CompareTo方法
TreeMap：底层是二叉树，线程不同步，可以用于给map集合中的键进行排序
 Map<String,String> map=new HashMap<String,String>();
 map.put("01","kingkong");
 map.put("02","Jack");
 添加相同的值，会覆盖原来的值
 map.remove("02");
 map.containsKey("02");
 Map<Sting,String> map=new HashMap<Sting,string>();
 map.put("01","kingkong");
 map.put("02","Jack");
 Set<String>keySet=map.keySet();
 Iterator<String>it=keySet.iterator();
 while(it.hasNext()){
  String key=it.next();
  //有了键就可以通过map集合的get方法获取其对应的value
  String value=map.get(key);
  //将Map中的映射关系取出，存入到Set集合中
  Set<Map.Entry<String,String>> entrySet=map.entrySet();
  Iterator<Map.Entry<String,String>>it=entrySet.iterator();
  while(it.hasNext()){
   Map.Entry<String,String>me=it.next();
   String key=me.getKey();
   String value=me.getValue();
  }
 }
 实现CompareTo方法
 
 
 Arrays是对数组操作的工具类
 asList：将数组变成List集合
 List<String>list=Arrays.asList(arr);
 
 增强for循环
   迭代器除了遍历，还可以进行remove集合中元素的动作
   如果是用ListIterator,还可以再遍历过程中对集合进行增删改查的操作
     ArrayList<String>a1=new ArrayList<String>(); 
     a1.add("kingkong");
  a1.add("Jack");
  for(String s: a1){ //只能取出不能对集合进行操作
  System.out.println(s);
  }
  int[] arr={2,4,6};
  for(int x:arr){
  System.out.println(x);
  }
--------------------------------------------------
Properties 是hashtable的子类，具备map集合的特点，而且里面存储的键值对是字符串

是集合中和IO技术想结合的集合容器

该对象的特点：可以用于键值对形式的配置文件
设置和获取元素
public static void setAndGt(){
 Properties prop=new Properties();
 
 prop.setProperty("john","10");
 prop.setProperty("jack","87");
 
 String value=prop.getProperty("jack");
 
 Set<String> names=prop.stringPropertyNames();
 
 for(String s:names){
  sop(prop.getProperty(s));
 }
}