java集合中的编号可以修改吗 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));
  }
 }