2019-03-15集合

集合

能保存一组任意类型数据的元素(只能保存引用数据类型，基本数据类型会经过包装类自动包装成对象)，并且可以自动扩容，比数组更具优势
Java中集合由两大接口代表Collection和Map
数组：他能保存一组一组元素，数据类型必须一致，定长

总结

Collection
*List 有序可重复
* ArrayList---基于数组实现的，访问速度快，插入删除速度慢
* LinkedList---基于列表实现的，访问速度慢，插入删除速度快（改变指向，内存不移动）
* Set无序不可重复
* HashSet
* TreeSet
* 常用方法：add（），size（），
Map：以键（key）值（value）对形式保存元素
* HashMap
* 常用方法：put（），size（），containskey（）

image.png
image.png

Collection接口：

list子接口 ----有序（元素存入的顺序和元素在集合当中真实的顺序一致）有重复

• ArrayList-

基于数组实现的，内部其实是创建了个长度为10的Object类型数组
当元素个数超过10，ArrayList自动扩容到原来的1.5倍
数组是一种静态线性表，逻辑是连续的，物理也是连续的 ,
优缺点：所以他的随机查询的速度比较快，插入删除速度慢

• Vetor

他是基于数组实现的，他与ArrayList的区别就在于Vector是数据同步（线程安全）

List list= new ArrayList();
// ArrayList list= new ArrayList();
// add添加元素
list.add("hello");
list.add(123);
list.add(false);
list.add(new Demo1());
System.out.println(list);
// get 获取元素
// System.out.println(list.get(1));
// size 元素个数，长度
// System.out.println(list.size());
// boolean isEmpty 判断集合是否为空，集合为空返回true（size=0），反之
// System.out.println(list.isEmpty());
// 没有list对象且集合元素为零
if(list !=null && !list.isEmpty()) {
}
// remove删除元素
// list.remove(0);    int 就是根据索引删除
list.remove("hello");  //删除元素hello
System.out.println(list);
// 遍历一
// for(int i = 0 ; i<list.size();i++) {
// System.out.println(list.get(i));
//
// }
// 遍历2
// for(Object ob:list) {
// System.out.println("---"+ob);
// }
}
}
// add(int,Object)插入
// set(int,Object)替换
// boolean contains（Object）返回集合中是否包含此元素

• LinkedList：

他是基于链表实现的，链表是动态线性表，逻辑是连续的，物理是不连续的,
优缺点： 所以他的查询速度比较慢，插入删除速度快

LinkedList list = new LinkedList<>();
list.add("hello");
list.add(123);
list.add(false);
// 拓展
list.addFirst("a");
list.addLast(212);
list.removeFirst();
list.removeLast();
System.out.println(list);
list.get(2);

Set子接口 ----无序（元素存入的顺序和元素在集合当中真实的顺序不一致）无重复

• HashSet

public class Demo4 {
public static void main(String[] args) {
Set set  = new HashSet<>();
        set.add(125);
        set.add("sdas");
        set.add("hello");
        set.add(false);
        set.add("hello");//无序无重复
        System.out.println(set);
        System.out.println(set.size());
        //删除具体元素
        set.remove(false);
        System.out.println(set);
        //遍历
        for(Object ob :set) {
        System.out.println(ob);
        }
}
}

• (TreeSet)：内部有排序，局限性强

Map：以键值对的形式保存元素

• HashMap
• TreeMap 内部有排序，局限性强

public class MapDemo1 {
public static void main(String[] args) {
// Map：以键值对的形式保存元素
//     键值不可以重复，否则值被覆盖，value可以重复
    /*    ==HashMap  数据不同步（线程不安全）      null可以作为key或者value
    *  -- ==HashTable  数据同步（线程安全）      null不可以作为key或者value
    *  -- ==TreeMap 内部有排序，局限性强
    *   
    *   
    *    常用方法  ：put、containskey
    */
Map map = new  HashMap<>();
//put(key【类型随意，相当于下标】,元素)
        map.put(1, "你好1");
        map.put(2, "你好2");
        map.put(3, "你好3");
        map.put(4, "你好4");
        System.out.println(map.get(1));
        System.out.println(map.size());
        //containsKey()  集合中是否包含相应的key值
        System.out.println(map.containsKey(1));
        System.out.println(map.containsValue("你好1"));
}
}

泛型

public class Demo6 {
public static void main(String[] args) {
// 泛型  :类型参数化<>遍历更方便了：强行规定集合只存某种类型的数据
List<String> list = new ArrayList<>();
list.add("sds");
List<Integer> list2 = new ArrayList<>();
list2.add(122);
List<Stedent> list3 = new ArrayList<>();
list3.add(new Stedent(1,"545"));
Set<Integer> set = new HashSet<>();
set.add(253);
Map<String, String> map = new HashMap<>();
map.put("dd", "aaa");
Map<String, Stedent> map1 = new HashMap<>();
map1.put("Java1", new Stedent(1,"545"));
Map<String, List<Stedent>> map2 = new HashMap<>();
}
}

遍历List

public class Demo7 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
//1不推荐
// for(int i =0;i< list.size();i++) {
// System.out.println(list.get(i));
// }
//2.迭代器遍历----专门遍历
Iterator iter = list.iterator();
while(iter.hasNext()) {//hasNext()若游标右侧有元素，则返回true
String str =(String)iter.next();//iter.next()取出游标右侧的元素，并且向右边移动
System.out.print(str+" ");
}
//3.推荐
for(String a: list) {
System.out.println(a);
}
}
}
HashSet遍历
public class Demo8 {
public static void main(String[] args){
Set<String> set =new HashSet<>();
set.add("A");
set.add("B");
set.add("C");
set.add("D");
// 1.foreach
for(String str: set){
System.out.println(str);
}
// 2.迭代器接口 -- 专门用来遍历的
Iterator iter =set.iterator();
while(iter.hasNext()) {// iter.hasNext() 若游标右侧有元素，则返回true
String str = (String)iter.next();//iter.next()取出游标右侧的元素，并将游标向右移动一位
System.out.println(str);
  }
    }
}

HashMap遍历

public class Demo9 {
public static void main(String[] args) {
Map<String, String>map = new HashMap<>();
map.put("java1","好" );
map.put("java2","很好" );
map.put("java3","非常好" );
map.put("java4","最好好" );
//1.迭代器
//keySet()返回map中Key值的Set集合
// Set<String>set = map.keySet();
//遍历key
// Iterator<String>  iter = set.iterator();
// while (iter.hasNext()) {
// String key  = iter.next();
// System.out.println(key+" "+map.get(key));
//
// }
//2.加强遍历
// for(String key :map.keySet()) {
// System.out.println(key +" "+map.get(key));
// }
// Entry 遍历
//   EntryshiMap接口中的内部接口
// map.entrySet()把map集合中每一组建值对都封装成一个Entry类型的对象存入了一个集合
for(Entry<String, String> entry: map.entrySet()) {
System.out.println(entry.getKey()+","+entry.getValue());
}
}
}