集合 （一个容器） 存储数据

 特点：1.长度可以变化（灵活度强）   2.只能存放对象  3.可以存放不同类的对象
 
 跟   《数组》的  区别 ： 数组的长度不可以变化    
 创建一个数组：int【】arr=new int【5】；  长度就是5   不可以增长
 
 CRUD  增    删    改   查
 API研究：
Collection  接口    不能具体创建对象来具体研究  往下层找
List  接口
ArrayList 类
ArrayList al=new ArrayList（）；默认创建了一个容量空间为10的容器


增（可以添加不同的对象）
al.add("ahjk");  添加单个数据  
al.add(new Object());  Object 类中的对象
存放其他对象  不光是字符串对象
/*al.add(new Person()); 下面Person类的对象
ArrayList al = new ArrayList();
添加对象
al.add(new Person("张三",20));
al.add(new Person("李四",21));
al.add(new Person("王五",22));
al.add(new Person("赵六",23));
//结合下面的get方法  输出
/*Iterator iterator = al.iterator();

while(iterator.hasNext()){
//强制转换
Person p = (Person) iterator.next();

System.out.println(p.getName()+"...."+p.getAge());*/


//System.out.println(al);
//如果没有复写toString方法   输出的是字符串的地址


class Person{

private String name;
private int age;
//构造方法
public Person(String name,int age) {
this.name=name;
this.age=age;
}
//第二种是getname  getage 方法  结合上面的迭代器输出本身
public String getName(){

return name;
}
public int getAge(){
return age;
}
//第一种方法是复写toString方法    就会输出字符串的本身 
///*@Override
public String toString() {

return name+":"+age;
}*/







*/
al.addAll（al1）;把一个容器添加到另一个容器中
 
 
 删（删除容器中的对象）
 al.clear();  清空一切
 al.remove("add");    删除一个数据  
 al.removeAll(al1);  删除al 中  与 al1  交集的数据
 
 查找
 al.isEmpty();  集合al是否为空  
 al.size();  集合al  的长度


 ***** Collection 中  iterator  迭代器   （查找元素,遍历集合）
 //获取迭代器
 Inerator iterator=al.iterator();
 //判断是否有下一个元素  hasNext();    hasNext的默认指针在第一个元素的上面
 //取出下一个元素   next();          判断是否有下一个元素  再往下走  保证遍历全部
 //通过迭代器（集合的内部类）取出集合中所有的对象
  while(iterator.hasNext()){
  System.out.println(iterator.next()); 
  }
 
 
 其他


 al.contains("adas");  判断al集合中是否 含有“adas”这个对象
 al.containsAll(al1);  判断al集合中  是否包含 al1中  所有的元素
 al.retainAll(al1);


Collection包括list 和 set


List  有序的存放数据，可以存放相同的元素
（ArrayList LinkedList   数组和链表    都有角标index   相同元素可以区分）


List中相对于collection中特殊的方法：操作带index的方法
al.add(1,"aaa");  可以把元素对象放到指定的位置
addAll(1,al1);    把al1从首位置为1的地方全部放入
al.get(0);         获取第0个位置的元素     有迭代器的功能  比较方便
al.set(0,"fff");  把第0个元素  修改成  "fff"
al.subList(0,5);  获取集合中  从第0个元素到第5-1个元素




*****************************************




Listiterator List迭代器   比迭代器功能全面
在Arraylist集合（List的子类对象才能用）中  直接用Listiterator
ArrayList al=new ArrayList();
listTterator li=al.listIterator();
//一进来就用hasprevious  往上没有数据  返回 false


while(li.hasNext()){
String str=(String)li.next();

if(str.equals("hd002")){
//在迭代器中添加
li.add("hd007");
//修改成hd007
li.set("hd007");
}
}
这样遍历完毕以后  指针在最后一个元素的下面一个位置   
用hasPervious  和 Previous  逆向遍历元素 


while(li.hasPrevious()){
System.out.println(li.previous());
}






                                   List






ArrayList   底层数据结构为数组  连续的内存空间   int [] arr=new int[5]


LinkedList  底层数据结构为链表    可能是连续的空间 
LinkedList (比前面的多的方法)
LinkedList ll=new LinkedList();
ll.add("aaa");
ll.add("tr");
ll.add("hk");
syso;
ll.addFirst("asd"); //  插入头部的
ll.addlast("df");  //插入尾部
ll.getFirst();  //获取第一个元素  返回值为空======  peekFirst 获取但不移除第一个 （更高级）
ll.getlast(); //获取最后一个元素  返回值为空======  peeklast  获取但不移除最后一个
ll.offerFirst();//插入第一个元素  返回值为boolean
ll.offerLast();//插入最后一个元素              offer  比 add  高级
removeFirst  removeLast  获取第一个或者最后一个元素  并且移除 
pollFirst    pollLast    获取第一个或者最后一个元素   并且移除 （更高级） 




******************************************




      Set   无序的存放数据，不可以存放相同的元素 


                   HashSet 底层数据结构为哈希表

HashSet hs=new HashSet();
hs.add("asd");
hs.add("sdggs");
hs.add("ewr");
hs.add("asd");
//存放的时候都要比较元素的Hashcode值  和 本身对象
Syso;//存放的顺序和输出的顺序不一样   并且相同的元素不能同时进入
String 字符串 存放的时候   已经写好  不用自己复写方法 
 
然而存放  类对象的时候   要复写HashCode方法和equals方法

例子：
hs.add(new Student("小明",15));
hs.add(new Student("小王",20));
hs.add(new Student("小红",21));
hs.add(new Student("小红",21));
//因为都是new出来的对象  所以HashCode地址肯定不一样   所以要想筛选出相同的对象
必须复写Hashcode   方法和   equals方法
//遍历
Iterator iterator = hs.iterator();
while(iterator.hasNext()){

Student stu = (Student) iterator.next();

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


class Student{

private String name;
private int age;
//alt+shift+s
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}

@Override
public int hashCode() {
// TODO Auto-generated method stub
//
return name.hashCode();
}

@Override
public boolean equals(Object obj) {
if(!(obj instanceof Student)){
throw new RuntimeException("必须存入学生对象");

}
Student stu = (Student)obj;
return this.age==stu.age;
}
HashSet 如何保证对象唯一呢？
hashCode()  和  equals();  如果都一样  不进行存储  对象相同
这两个方法写在对象类中   （对象与对象之间的比较）








                        TreeSet 底层数据结构为二叉树
TreeSet ts=new TreeSet();
ts.add("asdsa");
ts.add("uyk");
ts.add("hjmgn");
ts.add("asas");
syso();输入 按照字典（askii码）顺序

 TreeSet 的方式一 排序  ：让元素本身具有比较性

   TreeSet中存放student   按照姓名 年龄排序
   
   main 方法中 ：
   TreeSet ts =new TreeSet();
   ts.add(new Stu("张三",20));
    ts.add(new Stu("lisi",30));
ts.add(new Stu("wangwu",14));
 ts.add(new Stu("zhaoliu",13));
ts.add(new Stu("lisi",30));
//迭代器 遍历
Inerator iterator=ts.iterator();
while (iterator.hasNext){
Stu stu=(Stu)iterator.next();
syso(stu.getName()+"***"+stu.getAge);
}


   1.先让对象类实现Comparable 接口 ，再实现CompareTo（）；
 
   
   
   class Stu implements Comparable{
   private String name ;
   private int age;
   //构造方法
   public Stu(String name,int age){
   super();
   this.name=name;
   this.age=age;
   }
   //get方法
   public String getName(){
   return name;
   }
   public int age(){
   return age;
   }
   @实现Compaeable接口，compareTo方法（排序方法）
   public int compareto(Object o){
return 0; 认为第二个传入的对象和第一个传入的对象相等   只能输出迭代出一个
//return 1; 认为后面输出的比前面的小   倒序输出  从小到大
//return -1; 同return 1  排序相反
   }
    @实现Compareable接口，复写compareTo方法（比较方法）
public int compareto(Object o){
//判断是否为Stu
if（!(o instanceof Stu)）{
throw new RuntimeException("请传入学生对象");
}
//强转
Stu stu=(Stu)o;  


//1.相对来说比较简单的方法
int result= name.compareTo(stu.name);
if(result==0){
return new Integer(age).compareTo(new Integer(stu.age));
}else if(result>0){
return 1;
}
return -1;


//2.一般的方法相对来说比较麻烦的写法  
/****//比较姓名
int result=this.name.compareTo(stu.name);
//姓名相同
if(result==0){
//比较年龄
if(this.age==stu.age){
return 0;//不进行存储
}else if(this.age>stu.age){
return 1;
} 

}else if(result>0){
return 1;
}
 return -1;
}
        }***//
   
   TreeSet  的方式二  排序 ：让集合本身具有比较性


main 类中 ：
   TreeSet ts =new TreeSet(new MyComparator());//这样创建出来的集合本身就有比较器
   ts.add(new Student("张三",20));
   ts.add(new Student("李四",30));
   ts.add(new Student("王五",35));
   ts.add(new Student("李四",30));
   ts.add(new Student("赵六",19));
   //迭代器输出
   
   Iterator iterator=ts.iterator();
   while (iterator.hasNext()){
   //强转  因为Object类 中没有这个元素  
   Student stu=(Student)iterator.next();
   syso(stu.age+"***"+stu.name);
   }
   
class Student {
   private String name ;
   private int age;
   //构造方法
   public Stu(String name,int age){
   super();
   this.name=name;
   this.age=age;
   }
   //比较器
calss MyComparator implements Comparator{
  //复写compare方法
  public int compare(oBject o1,Object o2){
  //比较是否是学生对象
  if(!(o1 instanceof Student&& o2 instanceof Student))
  throw new RuntimeException(“必须传入学生对象");
  //强转
  Student s1=(Student)o1;
  Student s2=(Student)o2;
  int result=new Integer(s1.age).compareTo(new Integer(s2.age));
  //年龄相同比较姓名
if(result==0){
return s1.name.compareTo(s2.name);

}else if(result>0){
return 1;
}
return -1;
  }
}


注意：如果元素本身具有比较性 而且集合本身也具有比较性   


**********优先考虑集合本身的比较性来进行比较*********


集合比较性的由来：元素本身没有比较性的时候或者本身具有的比较性不是我们所需要的（因为不能修改）


-----String类元素本身具有比较性  （按照askii码比较）不能修改  但是想改成按照长度排序






public class Demo4{


main方法中


//让创建出来的集合具有比较性  加上字符串本身具有比较性
TreeSet ts=new TreeSet(new StringLenthComparator());
ts.add("asdasd");
ts.add("gh");
ts.add("asdf");
ts.add("rtet");
ts.add("tyiiui");
//迭代器遍历
  Iterator iterator=ts.iterator();
   while (iterator.hasNext()){
   //不用强转  本身就是字符串  
  
   syso(iterator.next());
   }
   


}
//创建一个长度比较器
class StringLenthComparator implements Comparator{
//复写compare方法
public int compare(Object o1, Object o2){
//强转为字符串
String str1=(String)o1;
String str2=(String)o2;
//比较长度

第一种方法：int result=new Integer(Str1.length()).compareTo(new Integer(str2.length()));
第二种方法：int result=str1.length()-str2.length();  //两个长度相减
if(result==0){
str1.compareTo(str2);

}else if(result>0){
return 1;
}

return -1;
}
}
**************************************************************************
知识：枚举的认识 
对于星期{1.2.3.4.5.6.7}长度已经确定 
性别：男 女             不能用变量来定义  常量也不方便定义的   可以用枚举


**************************************************************************


                             map 集合 (存放键值对)


main方法中：
 HashMap<String,Integer> hm=new HashMap<String,Integer>(); //存储结构为Hash表
     hm.put("hd001",20); 
     hm.put("hd002",25);
     hm.put("hd003",30);
     syso(hm);  //  输出结果{hd003=30,hd002=25,hd001=20}  以键值对形式存在
//判断是否有20 这个值 
boolean result2 = hm.containsValue(20);
System.out.println(result2);
 


如果想输出 ：hd001=zhangsan...20   hd002=lisi...30


main方法中：
HashMap hm1 = new HashMap();

hm1.put("hd001", new Person("zhangsan", 20));
hm1.put("hd002", new Person("lisi", 20));
hm1.put("hd002", new Person("wangwu", 20));
hm1.put("hd001", new Person("zhangsan", 20));

System.out.println(hm1);  //只输出两个   键值对相同时会进行覆盖操作

hm.remove("hd001");  //只删除键  就可以删除键值对
syso(hm);
 

//是否包含hd003 返回flase
boolean result1 = hm1.containsKey("hd003");
System.out.println(result1);
//通过键拿值
//通过hd001  拿到 zhangsan...20
Person p = (Person)hm1.get("hd001");
if(p!=null){  //如果p为空  报错 空指针异常  NullPointerException
System.out.println(p.name+"..."+p.age);
}
}
}
class Person{

String name;
int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return this.name+"..."+this.age;
}
}
 *************************map的两种遍历方法*********************
 public class Demo2 {


public static void main(String[] args) {

HashMap hm = new HashMap();


hm.put("hd001", new Person("aa", 20));
hm.put("hd002", new Person("bb", 20));
hm.put("hd003", new Person("cc", 10));
hm.put("hd004", new Person("dd", 14));
hm.put("hd005", new Person("ee", 14));
// 1.Set<K> keySet():获取所有键，再通过键  拿到值  
Set set = hm.keySet();

Iterator iterator = set.iterator();
while(iterator.hasNext()){
//System.out.println(iterator.next());
String key = (String)iterator.next();
Person p = (Person) hm.get(key);
System.out.println(key+"..."+p.name+"..."+p.age);
}


System.out.println("---------------------");
//2.Set<Map.Entry<K,V>> entrySet()  

Set set1 = hm.entrySet();


Iterator iterator1 = set1.iterator();

while(iterator1.hasNext()){

Entry entry = (Entry)iterator1.next();//映射关系 一个键对应一个值
String key = (String) entry.getKey(); // 映射关系中得到 键
Person value = (Person) entry.getValue();//映射关系中得到 值

System.out.println(key+"..."+value.name+"..."+value.age);
}
 



}


}