集合
能保存一组任意类型数据的元素(只能保存引用数据类型，基本数据类型会经过包装类自动包装成对象)，并且可以自动扩容，比数组更具优势
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());
}
}
}
