007-集合，list,set,map
2020-03-16 本文已影响0人
Ktry
集合的概念
集合就是一种存放数据容器
集合和数组的区别
数组：1、数组是定长，一旦定义长度不能改变
2、数组既可以存基本数据类型 int[] double[],还可以存放引用数据类型 Person[] User[]
3、数组中的每一个元素都是相同的数据类型 Object[]
集合：1、长度是可以改变的
2、集合只能存储引用数据类型 List<Integer>
3、集合可以保存不同类型的数据
Collection集合
- 常用方法
public class Demo1 {
public static void main(String[] args) {
//创建Collection接口对象
Collection coll = new ArrayList();
//boolean add(E e) 向集合中添加一个元素
coll.add(1);
coll.add("cxk");
coll.add(20.2);
//boolean addAll(Collection c) //向集合中添加一个集合
// void clear() 清空集合中的所有元素
//coll.clear();
//boolean contains(Object o) 判断集合中是否包含指定元素
boolean b = coll.contains(1);
System.out.println(b);
//boolean containsAll(Collection<?> c) 判断集合中是否包含指定集合
// boolean isEmpty() 判断集合是否为空(不是null)
boolean b1 = coll.isEmpty();
System.out.println(b1);
// boolean remove(Object o) 移除集合中指定元素,如果不存在该元素，则返回false
boolean b2 = coll.remove("cxk1");
System.out.println(b2);
// int size() 返回集合中元素的个数
int size = coll.size();
System.out.println(size);
// Object[] toArray() 将集合转换成数组
Object[] arr = coll.toArray();
System.out.println(Arrays.toString(arr));
System.out.println(coll);
}
}
迭代器
迭代器 判断集合中有没有下一个元素，如果有取出这个元素，并继续往下判断.......这个过程叫迭代
- 迭代器使用
public class Demo2 {
public static void main(String[] args) {
Collection coll = new ArrayList();
//添加元素
coll.add("cxk");
coll.add("李四");
coll.add("王五");
coll.add(100);
//集合的遍历
/**
* 增强for循环
*
* for(集合元素的类型 变量名:集合名){
* 变量名 ---->集合中每一个元素
* }
*/
// for (Object obj : coll) {
// System.out.println(obj);
// }
//迭代器 判断集合中有没有下一个元素，如果有取出这个元素，并继续往下判断.......这个过程叫迭代
//创建迭代器对象
Iterator it = coll.iterator();
//判断有没有下一个元素
while(it.hasNext()) {
//将游标向下移动，并且取出当前这个元素
System.out.println(it.next());
}
// System.out.println("是否有下一个元素"+it.hasNext());
// System.out.println("取出下一个元素"+it.next());
//
// System.out.println("是否有下一个元素"+it.hasNext());
// System.out.println("取出下一个元素"+it.next());
//
// System.out.println("是否有下一个元素"+it.hasNext());
// System.out.println("取出下一个元素"+it.next());
//
// System.out.println("是否有下一个元素"+it.hasNext());
// System.out.println("取出下一个元素"+it.next());
//
// System.out.println("是否有下一个元素"+it.hasNext());
// System.out.println("取出下一个元素"+it.next());
}
}
- 迭代器的问题
1、在迭代器迭代的过程中不要取增加或者删除元素。
2、在迭代器的循环里不要调用多次next方法
public class Demo3 {
public static void main(String[] args) {
// 在对集合进行迭代的时候，能不能向里面添加或者删除元素
// 判断有没有cxk如果有加入一个rose
Collection coll = new ArrayList();
coll.add("cxk");
coll.add("lisi");
coll.add("wangwu");
coll.add("zhaoliu");
coll.add("tianqi");
// 1、获取迭代器对象
Iterator it = coll.iterator();
// while(it.hasNext()) {
// if(it.next().equals("cxk")) {
// 在对集合进行迭代的时候，能不能向里面添加或者删除元素
// //coll.add("rose"); //错误
// //coll.remove("zhaoliu");//错误
// }
// }
// while(it.hasNext()) {
// if(it.next().equals("cxk")) {
// it.remove();
// }
// }
// Iterator it1 = coll.iterator();
// while(it1.hasNext()) {
// System.out.println(it1.next());
// }
//在迭代器循环中不要調用多次next方法
while (it.hasNext()) {
Object obj = it.next();
if (obj.equals("123")) {
// .......
}
System.out.println(obj);
}
}
}
泛型
jdk1.5之后的新特性
如果不使用泛型，那么在集合中存储元素或者获取元素，都需要不断向上转型和向下转型，有可能会出现类型转换异常。
使用泛型好处：实际上就是将类型转换的检查(提升到了编译期)
缺点：这样以来集合中能存储相同的数据类型
语法：
集合类型<泛型类型>
代码演示：
public class Demo4 {
public static void main(String[] args) {
//不使用泛型带来的问题
// Collection coll = new ArrayList();
//
// //将字符串变成Object 向上转型
// coll.add("cxk");
// coll.add("lisi");
// coll.add("王五");
// coll.add(20);
//
// //获取迭代器对象
// Iterator it = coll.iterator();
// while(it.hasNext()) {
// //从集合中获取元素得到Object类型
// Object obj = it.next();
// //将Object类型转换成String类型 向下转型
// String s = (String)obj;
// System.out.println(s.length());
// }
//表示Collection集合的泛型是String类型
//在jdk1.7之后泛型的右边可以省略不写
Collection<String> coll = new ArrayList<>();
coll.add("cxk");
coll.add("20");
coll.add("lsis");
//遍历元素 迭代器的泛型就是集合的泛型
Iterator<String> it = coll.iterator();
while(it.hasNext()) {
String s = it.next();
System.out.println(s);
}
}
}
ArrayList集合
- 常用方法
public class Demo1 {
public static void main(String[] args) {
//创建ArrayList集合，泛型为String
ArrayList<String> list = new ArrayList<>();
//向集合中添加元素
list.add("cxk");
list.add("lisi");
list.add("wangwu");
//void add(int index, E element) 将元素添加指定的下标位置。
list.add(3, "rose");
System.out.println(list);
//E get(int index) 获取指定下标上的元素
String str = list.get(0);
System.out.println(str);
//int indexOf(Object o) 获取指定元素在集合中下标位置，如果不存在返回-1
int index = list.indexOf("cxk");
System.out.println(index);
// E remove(int index) 移除集合中指定下标对应的元素，且返回该元素
String str1 = list.remove(3);
System.out.println(str1);//rose
System.out.println(list);
// E set(int index, E element) 修改指定的下标对应的元素，返回的是被修改之前的元素
String str2 = list.set(2, "斯古拉斯");
System.out.println(str2);
System.out.println(list);
}
}
- ArrayList遍历的三种方式
public class Demo2 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("cxk");
list.add("lisi");
list.add("wangwu");
//遍历有三种方式：
//1、foreach循环
// for (String string : list) {
// System.out.println(string);
// }
//2、for循环
// for(int i=0; i < list.size() ; i++) {
// System.out.println(list.get(i));
// }
//3、迭代器
// Iterator<String> it = list.iterator();
// while(it.hasNext()) {
// System.out.println(it.next());
// }
}
}
- ListIterator迭代器
//在ArrayList中使用ListIterator迭代器，可以实现边迭代，边操作元素
ListIterator<String> it = list.listIterator();
while(it.hasNext()) {
//System.out.println(lit.next());
String name = it.next();
if(name.equals("lisi")) {
//it.add("张三");
it.set("李四");
}
}
System.out.println(list);
LinkedList集合
public class Demo1 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<String>();
list.add("cxk");
list.add("lisi");
list.add("wangwu");
//void addFirst(E e) //在集合第一个位置上添加指定的元素
list.addFirst("rose");
System.out.println(list);
//void addLast(E e) //在集合最后一个位置上添加指定的元素
list.addLast("jack");
System.out.println(list);
//E element() //获取集合中的第一个元素
String str1 = list.element();
System.out.println(str1);
System.out.println(list);
// E getFirst() //获取集合的第一个元素
String str2 = list.getFirst();
System.out.println(str2);
System.out.println(list);
// E getLast() //获取集合的最后一个元素
String str3 = list.getLast();
System.out.println(str3);
System.out.println(list);
//boolean offer(E e)
boolean b = list.offer("hanmeimei");
System.out.println(b);
System.out.println(list);
// E peek() //获取集合的第一个元素
String str4 = list.peek();
System.out.println(str4);
System.out.println(list);
//E poll() //获取第一个元素，并将第一个元素移除
String str5 = list.poll();
System.out.println(str5);
System.out.println(list);
//E pop() //获取第一个元素，并将第一个元素移除
String str6 = list.pop();
System.out.println(str6);
System.out.println(list);
//void push(E e) //将指定的元素添加到第一个位置
list.push("lilei");
System.out.println(list);
// E remove() //移除集合中的第一个元素并返回这个元素
String str7 = list.remove();
System.out.println(str7);
System.out.println(list);
// E removeFirst() //移除集合中的第一个元素并返回这个元素
String str8 = list.removeFirst();
System.out.println(str8);
System.out.println(list);
// E removeLast() //移除集合中的最后一个元素并返回这个元素
String str9 = list.removeLast();
System.out.println(str9);
System.out.println(list);
}
}
常见面试题
ArrayList和LinkedList区别
1、ArrayList它底层使用数组实现的，所以在对ArrayList查询的时候效率高，增删的效率低
2、LinkedList它底层是双向链表结构，所以在对LinkedList查询的时候效率低，增删的效率高
ArrayList和Vector的区别
ArrayList和Vector底层都是用数组实现的，ArrayList是线程不安全的效率高，Vector是线程安全的效率低，Vector现在已经不使用
常见的数据结构
- 栈结构
- 数组结构
- 双向链表结构
- 红黑树
HashSet集合
特点：HashSet集合
1、无序的
2、不能重复
3、没有下标
- 代码实现
public class Demo1 {
public static void main(String[] args) {
//创建HashSet集合对象
HashSet<String> set = new HashSet<String>();
set.add("cxk");
set.add("lisi");
set.add("lisi");
set.add("wangwu");
set.add("重地");
set.add("通话");
System.out.println(set);
// Iterator<String> it = set.iterator();//Curl+1
// while(it.hasNext()) {
// System.out.println(it.next());
// }
}
}
LinkedHashSet集合
特点：LinkedHashSet集合
1、有序的
2、不能重复
3、没有下标
public class Demo2 {
public static void main(String[] args) {
LinkedHashSet<String> set = new LinkedHashSet<String>();
set.add("cxk");
set.add("wangwu");
set.add("wangwu");
set.add("lisi");
System.out.println(set);
}
}
HashMap基本使用
public class Demo1 {
public static void main(String[] args) {
// //K 表示键的类型 V 值的类型
// Map<String, String> map = new HashMap<>();
// //向Map集合中添加元素
// map.put("name", "张三");
// map.put("age", "30");
// map.put("sex", "男");
// map.put("hobby", "篮球");
// //简单输出
// System.out.println(map);
//
// //获取指定的元素 根据key取value
// String name = map.get("name");
// System.out.println(name);
Map<String, String> map = new HashMap<>();
map.put("name", "cxk");
map.put("cn", "中国");
map.put("us", "美国");
map.put("cn", "中国人民共和国");
map.put("china", "中国人民共和国");
//简单输出
System.out.println(map);
//map的特点：key是不能重复的。如果有重复。后面会将前面覆盖 value可以重复
}
}
map的特点：key是不能重复的。如果有重复。后面会将前面覆盖 value可以重复
HashMap的其他方法
public class Demo2 {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("name", "cxk");
map.put("cn", "中国");
map.put("us", "美国");
map.put("cn", "中国人民共和国");
map.put("china", "中国人民共和国");
// Set<K> keySet() 获取map集合中所有的key
Set<String> set = map.keySet();
for (String s : set) {
//System.out.println(s);
}
//Collection<V> values() 获取map集合中所有的value
Collection<String> values = map.values();
for (String s : values) {
//System.out.println(s);
}
//Set<Map.Entry<K,V>> entrySet() 获取Map集合中的所有键和值组成的Entry对象
//Map集合实际就是Entry
Set<Entry<String, String>> entrySet = map.entrySet();
for (Entry<String, String> entry : entrySet) {
//System.out.println(entry);
//取出entry对象中的key
System.out.println(entry.getKey());
//取出entry对象中的value
System.out.println(entry.getValue());
}
System.out.println("----------------------------------------------------------");
//是否包含指定的key
boolean b1 = map.containsKey("name");
System.out.println("是否包含name这个key:"+b1);
//是否包含指定value
boolean b2 = map.containsValue("中国");
System.out.println("是否包含中国这个value:"+b2);
//根据指定key移除这个键值对，如果存在key返回这个value，如果不存在key返回null
String s = map.remove("name");
System.out.println(s);
System.out.println(map);
//如果添加元素的时候，这个key存在，返回这个key所对应的值，并覆盖为新的value
//如果key不存在，返回的都是null
String s1 = map.put("cn", "30");
System.out.println(s1);
System.out.println(map);
}
}
HashTable类
public class Demo1 {
public static void main(String[] args) {
// Map<String, String> map = new Hashtable<String, String>();
// map.put("name", "cxk");
// map.put("name", "zhangsan");
// map.put("age", "30");
// //map.put("sex", null);
// map.put(null, "hha");
// System.out.println(map);
Map<String, String> map = new HashMap<String, String>();
map.put(null, "你好");
map.put("name",null);
map.put(null,null);
System.out.println(map);
String str1 = map.get(null);
System.out.println(str1);
//HashMap和HashTable区别
//1、HashMap是线程不安全的，HashTable线程安全的
//2、HashMap的键和值都可以为null，HashTable不可以
}
}
HashMap和HashTable区别
1、HashMap是线程不安全的，HashTable线程安全的
2、HashMap的键和值都可以为null，HashTable不可以
Map与实体类对比
public class Demo1 {
public static void main(String[] args) {
List<Book> list =new ArrayList<>();
Book book1 = new Book(1, "三国", "罗贯中", 100);
Book book2 = new Book(2, "水浒传", "施耐庵", 80);
Book book3 = new Book(3, "西游记", "吴承恩", 90);
list.add(book1);
list.add(book2);
list.add(book3);
System.out.println(list);
System.out.println("-----------------------------------------------");
Map<String, Object> map1 = new HashMap<>();
map1.put("id", 1);
map1.put("name","三国");
map1.put("author","罗贯中");
map1.put("price",100);
Map<String, Object> map2 = new HashMap<>();
map2.put("id", 2);
map2.put("name","水浒传");
map2.put("author","施耐庵");
map2.put("price",80);
Map<String, Object> map3 = new HashMap<>();
map3.put("id", 3);
map3.put("name","西游记");
map3.put("author","吴承恩");
map3.put("price",90);
List<Map<String, Object>> list1 = new ArrayList<Map<String,Object>>();
list1.add(map1);
list1.add(map2);
list1.add(map3);
System.out.println(list1);
}
}
测试
/**
* 利用集合保存省市数据
*/
public class Demo1 {
public static void main(String[] args) {
Map<String, List<String>> map = new HashMap<String, List<String>>();
List<String> list1 = new ArrayList<String>();
list1.add("武汉");
list1.add("黄冈");
list1.add("黄石");
List<String> list2 = new ArrayList<String>();
list2.add("长沙");
list2.add("湘潭");
list2.add("常德");
map.put("湖北",list1 );
map.put("湖南",list2);
List<String> citys = map.get("湖北");
System.out.println(citys);
}
}
