标签：list1 System println add 集合 public out
第五章——集合
1、Collection接口
Collection接口概述
Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。
/*
到目前位置，我们学习过哪些可以存储元素的容器：
1、数组
优点：不同的数组可以存储不同数据类型的元素
缺点：长度不可变
2、StringBuffer|StringBuilder
优点：长度可以跟随元素的数量而改变
缺点：里面的元素只有一种字符数据类型
我们今后会根据元素的是否重复，存储和取出的顺序等来决定我们该使用什么样的容器来进行存储
根据我现实生活中经验来说，容器应该是丰富多彩的，多种多样的
java应该要使用若干个不同的类来描述不同的容器，表示不同容器的特点。
容器应该都有若杠共同的特点，都可以装东西等。
那么java中提供的这些类中成员应该也会有相同的部分，那我们将其向上提取，由继承或实现来构建关系
这样我们就可以得到一个继承体系。
Collection【接口】:
我们通过帮助文档发现，Collection是一个接口，不能直接new对象
根据元素是否可以发生重复，继续分类
- List【接口】元素可以发生重复，且有索引的概念
ArrayList
- Set【接口】元素不可以发生重复，没有索引
借助ArrayList子类对象来使用Collection接口中的方法
学习java中任意一个集合的步骤：
1、创建相关集合对象
2、创建元素对象
3、将元素添加到集合中
4、遍历集合
Collection中的成员方法：
boolean add(E e)
boolean remove(Object o)
void clear()
boolean contains(Object o)
boolean isEmpty()
int size()
*/
public class CollectionDemo1 {
public static void main(String[] args) {
//借助ArrayList创建对象来使用Collection接口中的方法
// 1、创建相关集合对象
Collection c1 = new ArrayList();
//boolean add(Object e)
c1.add(100); //这里涉及到自动装箱 int -> Integer
c1.add(true);
c1.add(12.34);
c1.add(1000L);
c1.add(100);
c1.add(12.34);
// 重写toString()方法的类是ArrayList类的父类的父类中重写的。
// 底层是使用StringBuilder实现的
System.out.println("c1: " + c1);
//注意：我们今后使用集合的时候，规定一个集合只能存储一种数据类型的元素
System.out.println("-----------------------------------------");
//[100, true, 12.34, 1000, 100, 12.34]
//boolean remove(Object o) 从集合中删除一个元素,只会删除最左边的一个匹配元素
c1.remove(100);
System.out.println("c1: " + c1);
System.out.println("-----------------------------------------");
//void clear() 清空集合元素
// c1.clear();
// System.out.println("c1: " + c1);
System.out.println("-----------------------------------------");
//boolean contains(Object o) 判断Collection集合中是否包含某个元素
System.out.println(c1.contains(12.34));
System.out.println("-----------------------------------------");
//boolean isEmpty() 判断Collection集合是否为空
System.out.println(c1.isEmpty());
System.out.println("-----------------------------------------");
//int size() 获取集合的长度【元素的个数】
System.out.println(c1.size());
}
}
============================================================
/*
boolean addAll(Collection c)
boolean removeAll(Collection c)
boolean containsAll(Collection c)
boolean retainAll(Collection c)
*/
public class CollectionDemo2 {
public static void main(String[] args) {
//创建集合对象
Collection c1 = new ArrayList();
c1.add("java");
c1.add("maven");
c1.add("clickhouse");
c1.add("redis");
Collection c2 = new ArrayList();
c2.add("java");
c2.add("hadoop");
c2.add("maven");
c2.add("hive");
c2.add("hbase");
c2.add("数据采集");
System.out.println("c1: "+c1);
System.out.println("c2: "+c2);
System.out.println("------------------------------");
//boolean addAll(Collection c)
// c1.addAll(c2);
// System.out.println("c1: "+c1);
// System.out.println("c2: "+c2);
//boolean removeAll(Collection c)
// c1.removeAll(c2);
// System.out.println("c1: "+c1);
// System.out.println("c2: "+c2);
//boolean containsAll(Collection c)
// System.out.println(c1.containsAll(c2));
// System.out.println("c1: "+c1);
// System.out.println("c2: "+c2);
//boolean retainAll(Collection c) 求交集 将结果保存在调用方法的对象集合中
c1.retainAll(c2);
System.out.println("c1: "+c1);
System.out.println("c2: "+c2);
}
}
============================================================
import java.util.ArrayList;
import java.util.Collection;
/*
如何遍历一个Collection集合
1、Object[] toArray() 把集合转成数组，可以实现集合的遍历
*/
public class CollectionDemo3 {
public static void main(String[] args) {
Collection c1 = new ArrayList();
c1.add("hello");
c1.add("world");
c1.add("java");
c1.add("hadoop");
c1.add("world");
Object[] objects = c1.toArray();
for(int i=0;i<objects.length;i++){
Object obj = objects[i]; // "hello"
String s = (String)obj;
//向下转型，才可使用元素自己类型的方法
System.out.println(s+"-"+s.length());
}
}
}
============================================================
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
Iterator iterator() 迭代器，集合的专用遍历方式
*/
public class CollectionDemo4 {
public static void main(String[] args) {
Collection c1 = new ArrayList();
c1.add("hello");
c1.add("world");
c1.add("java");
c1.add("hadoop");
c1.add("world");
//Collection类型的集合本身是不可以直接遍历的
//需要生成对应的迭代器，迭代器中存储了集合中的元素
//将来遍历迭代器就可以获取集合中的元素了
//生成迭代器
Iterator iterator = c1.iterator(); // new Itr()
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next()); // NoSuchElementException
//每一个迭代器，都有一个独立指针，每调用一次next()方法，就会向后移动一次指针取数据
//如何判断下一个位置上是否有元素呢？
while (iterator.hasNext()){
Object obj = iterator.next();
String s = (String)obj;
System.out.println(s+"-"+s.length());
}
}
}
============================================================
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
Collection集合存储自定义对象
1、创建集合对象
2、创建元素对象
3、将元素添加到集合中
4、遍历集合
*/
public class CollectionDemo5 {
public static void main(String[] args) {
//1、创建集合对象
Collection c1 = new ArrayList();
//2、创建元素对象
Student s1 = new Student("李刚", 15);
Student s2 = new Student("江川", 11);
Student s3 = new Student("钱志强", 17);
Student s4 = new Student("祝帅", 15);
// 3、将元素添加到集合中
c1.add(s1);
c1.add(s2);
c1.add(s3);
c1.add(s4);
// 4、遍历集合
//方式1：转数组遍历
// Object[] objects = c1.toArray();
// for(int i=0;i<objects.length;i++){
// Object obj = objects[i];
// Student s = (Student) obj;
// System.out.println(s.getName()+"-"+s.getAge());
// }
//方式2：迭代器遍历
Iterator iterator = c1.iterator();
while (iterator.hasNext()){
Object obj = iterator.next();
Student s = (Student) obj;
System.out.println(s.getName()+"-"+s.getAge());
}
}
}
2、List接口
List接口概述
有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
与 set 不同，列表通常允许重复的元素。
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
/*
List集合：元素可以发生重复，有序(指存储和取出的顺序一致)
Collection【接口】：
- List【接口】
ArrayList
- Set【接口】
List集合中特有的成员方法：
void add(int index,E element)
E remove(int index)
E get(int index)
E set(int index,E element)
ListIterator listIterator()
*/
public class ListDemo1 {
public static void main(String[] args) {
List list1 = new ArrayList();
list1.add("hello");
list1.add("apple");
list1.add("banana");
list1.add("watermelon");
list1.add("mango");
System.out.println("list1: " + list1);
System.out.println("==================================");
//因为List相关集合具备索引的特点，List集合根据索引提供一些其它集合没有的方法
//void add(int index,E element) 指定索引位置添加元素 grape
list1.add(2,"grape");
System.out.println("list1: " + list1);
System.out.println("==================================");
// E remove(int index) 根据索引从集合中移除元素
System.out.println(list1.remove(2));
System.out.println("list1: " + list1);
System.out.println("==================================");
//E get(int index) 根据索引获取对应元素
System.out.println(list1.get(3));
System.out.println("list1: " + list1);
System.out.println("==================================");
//E set(int index,E element) 指定索引位置修改元素
System.out.println(list1.set(3, "orange"));
System.out.println("list1: " + list1);
System.out.println("==================================");
//ListIterator listIterator()
ListIterator listIterator = list1.listIterator();
//从前向后取
while (listIterator.hasNext()){
System.out.println(listIterator.next());
}
System.out.println("==================================");
//从后向前取
//注意：一个集合迭代器只有一个游标，要想倒着遍历，必须先正着遍历一遍，所以该方法用的较少
while (listIterator.hasPrevious()){
System.out.println(listIterator.previous());
}
}
}
============================================================
/*
需求：遍历集合，当遇到mango的时候，向集合中添加一个元素"java"
我们发现如果使用迭代器遍历，集合发生修改的话，报错了
ConcurrentModificationException
*/
public class ListDemo2 {
public static void main(String[] args) {
List list1 = new ArrayList();
list1.add("hello");
list1.add("apple");
list1.add("banana");
list1.add("watermelon");
list1.add("mango");
list1.add("peach");
list1.add("pear");
System.out.println("list1: " + list1);
System.out.println("======================================");
//1、转数组遍历
// Object[] objects = list1.toArray();
// for(int i=0;i<objects.length;i++){
// Object obj = objects[i];
// String s = (String) obj;
// if("mango".equals(s)){
// list1.add("java");
// }
// }
// System.out.println("list1: "+list1);
// System.out.println("======================================");
//2、使用迭代器遍历
// Iterator iterator = list1.iterator();
// while (iterator.hasNext()){
// Object obj = iterator.next();
// String s = (String) obj;
// if("mango".equals(s)){
// list1.add("java");
// }
// }
// System.out.println("list1: "+list1);
//使用List集合中特有的迭代器进行遍历比较，且使用它进行添加元素
ListIterator listIterator = list1.listIterator();
while (listIterator.hasNext()) {
Object obj = listIterator.next();
String s = (String) obj;
if ("mango".equals(s)) {
listIterator.add("java");
}
}
System.out.println("list1: " + list1);
}
}
3、ArrayList类 Vector类 LinkedList类
/*
Collection[接口]:
List[接口]: 元素有序，可以发生重复，有索引的概念
ArrayList[具体的子类]: 底层数据结构是数组，查询快，增删慢，线程不安全，效率高。
Set[接口]: 元素无序且唯一，没有索引
*/
public class ArrayListDemo1 {
public static void main(String[] args) {
//创建集合对象
ArrayList list1 = new ArrayList();
//创建元素对象
//将元素添加到集合中
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hadoop");
list1.add("hello");
list1.add("world");
//遍历集合
//1. 转数组遍历
Object[] objects = list1.toArray();
for(int i=0;i<objects.length;i++){
System.out.println(objects[i]);
}
System.out.println("========================");
//2. 使用迭代器的方式遍历
Iterator iterator = list1.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("========================");
//3. 使用size()和get(i) 只有List集合才拥有的遍历方式
for(int i=0;i<list1.size();i++){
System.out.println(list1.get(i));
}
}
}
============================================================
/*
ArrayList
去除集合中字符串的重复值(字符串的内容相同)
*/
public class ArrayListTest1 {
public static void main(String[] args) {
ArrayList list1 = new ArrayList();
//创建元素对象
//将元素添加到集合中
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hadoop");
list1.add("hello");
list1.add("world");
System.out.println("list1: " + list1);
System.out.println("-----------------------------");
//创建一个新的集合
ArrayList list2 = new ArrayList();
for (int i = 0; i < list1.size(); i++) {
String str = (String) list1.get(i);
if (!list2.contains(str)) {
list2.add(str);
}
}
System.out.println("list2: " + list2);
}
}
============================================================
/*
去除集合中自定义对象的重复值(对象的成员变量值都相同)
我们按照实现去重字符串的逻辑去重自定义对象，发现自定义对象并没有去重
我们要去看contains的源码，底层判断元素是否存在新集合的逻辑是：
挨个使用待插入的元素与新集合中的元素使用equals方法比较，我们元素Student类中并没有重写equals方法
所以使用的是父类Object中的equals方法，而父类Object中的equals方法比较的是地址值
又因为每一个学生都是new出来的，所以地址值都不一样，比较的结果永远为false
要想比较内容值，需要元素类型重写equals方法，自动生成即可
*/
public class ArrayListTest2 {
public static void main(String[] args) {
ArrayList list1 = new ArrayList();
Student s1 = new Student("李刚", 15);
Student s2 = new Student("钱志强", 16);
Student s3 = new Student("江川", 30);
Student s4 = new Student("李刚", 15);
Student s5 = new Student("祝帅", 15);
list1.add(s1);
list1.add(s2);
list1.add(s3);
list1.add(s4);
list1.add(s5);
System.out.println("list1: " + list1);
System.out.println("=================================");
ArrayList list2 = new ArrayList();
for(int i=0;i<list1.size();i++){
Student s = (Student) list1.get(i);
/*
//Student s1 = new Student("李刚", 15);
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
*/
if(!list2.contains(s)){
list2.add(s);
}
}
System.out.println("list2: " + list2);
}
}
============================================================ /*
Collection[接口]:
List[接口]: 元素有序，可以发生重复，有索引的概念
ArrayList[具体的子类]: 底层数据结构是数组，查询快，增删慢，线程不安全，效率高。
Vector[具体的子类]: 底层数据结构是数组，查询快，增删慢，先出安全，效率低。
即便Vector是线程安全的，我们以后也不会用它。
特殊的功能：
public void addElement(E obj)
public E elementAt(int index)
public Enumeration elements()
Set[接口]: 元素无序且唯一，没有索引
*/
public class VectorDemo1 {
public static void main(String[] args) {
//创建Vector集合对象
Vector v1 = new Vector();
//创建元素并添加元素
v1.add("hello");
v1.add("world");
v1.add("java");
v1.add("hadoop");
v1.add("hbase");
v1.add("java");
v1.add("hello");
System.out.println("v1: "+v1);
System.out.println("-------------------------------");
//public void addElement(Object obj) 向集合中添加元素
// v1.addElement("flink");
// System.out.println("v1: "+v1); // 效果和add方法一模一样，可以使用add方法替代
//public Object elementAt(int index) 根据索引获取元素
// System.out.println(v1.elementAt(2));// 效果和get方法一模一样，可以使用get方法替代
// System.out.println(v1.get(2));
//public Enumeration elements()
// Enumeration elements = v1.elements();// 效果和迭代器方法一模一样，可以使用迭代器方法替代
// while (elements.hasMoreElements()){
// System.out.println(elements.nextElement());
// }
}
}
============================================================ /*
Collection[接口]:
List[接口]: 元素有序，可以发生重复，有索引的概念
ArrayList[具体的子类]: 底层数据结构是数组，查询快，增删慢，线程不安全，效率高。
Vector[具体的子类]: 底层数据结构是数组，查询快，增删慢，先出安全，效率低。
即便Vector是线程安全的，我们以后也不会用它。
特殊的功能：
public void addElement(E obj)
public E elementAt(int index)
public Enumeration elements()
LinkedList[具体的子类]: 底层数据结构是双链表，增删快，查询慢，线程不安全，效率高
特殊功能：
public void addFirst(E e)及addLast(E e)
public E getFirst()及getLast()
public E removeFirst()及public E removeLast()
Set[接口]: 元素无序且唯一，没有索引
*/
public class LinkedListDemo1 {
public static void main(String[] args) {
LinkedList list1 = new LinkedList();
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hello");
list1.add("world");
list1.add("hadoop");
System.out.println("list1: "+list1);
System.out.println("=====================");
//public void addFirst(E e)及addLast(E e)
list1.addFirst("李刚");
list1.addLast("钱志强");
System.out.println("list1: "+list1);
System.out.println("----------------------");
//public Object getFirst()及getLast()
System.out.println(list1.getFirst());
System.out.println(list1.getLast());
System.out.println("list1: "+list1);
System.out.println("----------------------");
//public E removeFirst()及public E removeLast()
System.out.println(list1.removeFirst());
System.out.println(list1.removeLast());
System.out.println("list1: "+list1);
}
}
4、泛型
/*
泛型是将来用于接收一个引用数据类型的，相当于一个参数
既然是参数，就需要符合标识符的命名规则
一般情况下，使用一个或多个大写字母表示
*/
//泛型类
public class Demo<W> {
public void fun1(W w) {
System.out.println("接收到的参数是：" + w);
}
}
class Test1{
public static void main(String[] args) {
// Demo demo = new Demo();
// demo.fun1("hello");
// demo.fun1(10);
// demo.fun1(12.34);
Demo<String> d1 = new Demo<>();
d1.fun1("hello");
// d1.fun1(10);
}
}
============================================================
public class Demo1 {
//泛型方法
public <Q> void fun1(Q q) {
System.out.println("接收到的参数是：" + q);
}
//普通的方法
public void fun2(Object obj) {
System.out.println("接收到的参数是：" + obj);
}
}
class Test2{
public static void main(String[] args) {
Demo1 demo1 = new Demo1();
demo1.fun1("hello");
demo1.fun1(100);
}
}
============================================================
//泛型接口
public interface Inter1<P> {
void show1(P p);
}
class Inter1Impl<P> implements Inter1<P> {
@Override
public void show1(P p) {
System.out.println("接收到参数值是：" + p);
}
}
class Test3{
public static void main(String[] args) {
Inter1Impl<String> stringInter1 = new Inter1Impl<>();
stringInter1.show1("hello");
// stringInter1.show1(123);
}
}
5、Set接口
Set接口概述
一个不包含重复元素的 collection。
Set案例
存储字符串并遍历
存储自定义对象并遍历
/*
Set:
HashSet: 底层数据结构是哈希表，查找速度快，且元素唯一
HashSet中的add方法实际上调用的是HashMap中的put方法
底层和元素的hashCode方法值有关
我们发现，底层判断待插入的元素是否已经存在哈希表中的方式是：
将待插入的元素的哈希值与已经存储在哈希表中元素哈希值进行比较，
然后再调用待插入的元素的equals方法比较已经存储在哈希表中元素。
若哈希值一样，且equals结果为true，就表示这两个元素是同一个元素，不做添加
结论：
若想要使用HashSet对元素进行去重，需要元素类型本身重写hashCode方法和equals方法。
*/
public class HashSetDemo1 {
public static void main(String[] args) {
//使用HashSet存储字符串元素
HashSet<String> set1 = new HashSet<>();
//添加元素
set1.add("hello");
set1.add("world");
set1.add("hello");
set1.add("java");
set1.add("hello");
set1.add("hadoop");
System.out.println("set1: " + set1);
}
}
============================================================
/*
Collection:
List:
Set:
HashSet:
- LinkedHashSet:
TreeSet: 底层数据结构是红黑树（自平衡二叉树），具备了可预测的排序
- 自然排序
- 比较器排序
TreeSet中的add方法实际上是调用了TreeMap中的put方法
*/
public class TreeSetDemo1 {
public static void main(String[] args) {
// 使用TreeSet集合存储字符串元素【注意观察元素是否唯一，有没有排序】
// 思考：怎么实现的唯一和排序？
TreeSet<String> set1 = new TreeSet<>();
set1.add("strawberry");
set1.add("grape");
set1.add("mango");
set1.add("apple");
set1.add("strawberry");
set1.add("banana");
set1.add("coconut");
for (String s : set1) {
System.out.println(s);
}
}
}
============================================================
/*
要想使用TreeSet集合存储自定义对象且使用的是无参构造方法创建TreeSet集合对象的话，
需要元素类型实现Comparable<元素类型>接口,实现compareTo方法
compareTo方法根据需求来定制
*/
public class TreeSetDemo2 {
public static void main(String[] args) {
//使用TreeSet存储自定义对象
TreeSet<Teacher> set1 = new TreeSet<>();
//需求：当姓名和年龄一样的时候去重，年龄需要从小到大排序
Teacher t1 = new Teacher("笑哥", 18);
Teacher t2 = new Teacher("小虎", 15);
Teacher t3 = new Teacher("凯哥", 17);
Teacher t4 = new Teacher("笑哥", 18);
Teacher t5 = new Teacher("杨老板", 18);
set1.add(t1);
set1.add(t2);
set1.add(t3);
set1.add(t4);
set1.add(t5);
for (Teacher teacher : set1) {
System.out.println(teacher);
}
}
}
============================================================
//Teacher类
public class Teacher implements Comparable<Teacher>{
private String name;
private int age;
public Teacher() {
}
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Teacher{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Teacher o) {
//cmp = k.compareTo(t.key);
// this - 待插入元素
// o - 要比较的根元素
//当姓名和年龄一样的时候去重，年龄需要从小到大排序
// return this.age - o.getAge();
//显式条件
int i1 = this.age - o.getAge();
//隐式条件
//当年龄一样的时候，姓名不一定一样
return (i1==0)?this.name.compareTo(o.name):i1;
}
}
============================================================
public class TreeSetDemo3 {
public static void main(String[] args) {
//使用比较器排序，按照年龄从小到大排序
// public TreeSet(Comparator<? super E> comparator) {
// this(new TreeMap<>(comparator));
// }
TreeSet<Cat> set1 = new TreeSet<>(new Comparator<Cat>() {
@Override
public int compare(Cat o1, Cat o2) {
// o1是待插入的元素
// o2是要比较的根元素
int i1 = o1.getAge() - o2.getAge();
return (i1 == 0) ? o1.getName().compareTo(o2.getName()) : i1;
}
});
Cat c1 = new Cat("汤姆", 8);
Cat c2 = new Cat("黑猫警长", 2);
Cat c3 = new Cat("加菲猫", 4);
Cat c4 = new Cat("汤姆", 8);
Cat c5 = new Cat("哆啦A梦", 6);
set1.add(c1);
set1.add(c2);
set1.add(c3);
set1.add(c4);
set1.add(c5);
for (Cat cat : set1) {
System.out.println(cat);
}
}
}
6、Map接口
Map接口概述
将键映射到值的对象
一个映射不能包含重复的键
每个键最多只能映射到一个值
Map接口和Collection接口的不同
Map是双列的,Collection是单列的
Map的键唯一,Collection的子体系Set是唯一的
Map集合的数据结构值针对键有效，跟值无关
Collection集合的数据结构是针对元素有效
Map接口成员方法
V put(K key,V value)
V remove(Object key)
void clear()
boolean containsKey(Object key)
boolean containsValue(Object value)
boolean isEmpty()
int size()
V get(Object key)
Set<K> keySet()
Collection<V> values()
Set<Map.Entry<K,V>> entrySet()
/*
Map集合：元素是键值对构成的
Map特点：
1、在同一个Map集合中，键是唯一的
2、在同一个Map集合中，值可以发生重复
3、一对键值，表示Map集合中的一个元素
Map集合中的方法：
V put(K key,V value)
V remove(Object key)
void clear()
boolean containsKey(Object key)
boolean containsValue(Object value)
boolean isEmpty()
int size()
V get(Object key)
Set<K> keySet()
Collection<V> values()
Set<Map.Entry<K,V>> entrySet()
*/
public class MapDemo1 {
public static void main(String[] args) {
HashMap<Integer, String> map1 = new HashMap<>();
//V put(K key,V value) 向集合中添加一对元素 返回键原本的旧值
// System.out.println(map1.put(1001, "李刚"));
// System.out.println("map1: " + map1);
// System.out.println("----------------------");
// System.out.println(map1.put(1001, "xiaohu"));
// System.out.println("map1: " + map1);
map1.put(1001, "李刚1");
map1.put(1002, "李刚2");
map1.put(1003, "李刚3");
map1.put(1001, "李刚4");
map1.put(1004, "李刚5");
System.out.println("map1: " + map1);
System.out.println("----------------------");
//V remove(Object key) 根据键移除一个键值对
// System.out.println(map1.remove(1001));
// System.out.println("map1: " + map1);
//void clear()
// map1.clear();
// System.out.println("map1: " + map1);
//boolean containsKey(Object key) 判断键是否存在
// System.out.println(map1.containsKey(1001));
//boolean containsValue(Object value) 判断值是否存在
// System.out.println(map1.containsValue("李刚1"));
//boolean isEmpty() 判断Map集合中是否有键值对
// System.out.println(map1.isEmpty());
//int size() 返回Map集合中键值对的元素个数
// System.out.println(map1.size());
//V get(Object key) 根据键获取值
// System.out.println(map1.get(1001));
// System.out.println(map1.get(1009)); // null
//Set<K> keySet() 获取所有的键
// Set<Integer> keySet = map1.keySet();
// for (Integer i : keySet) {
// System.out.println(i);
// }
//Collection<V> values() 获取所有的值
// Collection<String> values = map1.values();
// for (String value : values) {
// System.out.println(value);
// }
}
}
============================================================
public class MapDemo2 {
public static void main(String[] args) {
//Map集合遍历
HashMap<Integer, String> map1 = new HashMap<>();
map1.put(1001, "李刚1");
map1.put(1002, "李刚2");
map1.put(1003, "李刚3");
map1.put(1001, "李刚4");
map1.put(1004, "李刚5");
System.out.println("map1: " + map1);
System.out.println("----------------------");
// 方式1：获取所有的键，遍历键，根据键获取值
// Set<Integer> keySet = map1.keySet();
// for (Integer key : keySet) {
// String value = map1.get(key);
// System.out.println(key + "-" + value);
// }
// 方式2：直接获取所有的键值对，遍历每一个键值对得到每一个键和值
//Set<Map.Entry<K,V>> entrySet()
Set<Map.Entry<Integer, String>> entries = map1.entrySet();
for (Map.Entry<Integer, String> entry : entries) {
Integer key = entry.getKey();
String value = entry.getValue();
System.out.println(key + ":" + value);
}
}
}
============================================================
/*
HashMap<Student3,String>
Map的唯一性指的是键的唯一性，HashMap中需要键的类型要重写hashCode()方法和equals方法
*/
public class HashMapDemo1 {
public static void main(String[] args) {
HashMap<Student3, String> map1 = new HashMap<>();
Student3 s1 = new Student3("李刚", 21);
Student3 s2 = new Student3("钱志强", 22);
Student3 s3 = new Student3("江川", 21);
Student3 s4 = new Student3("李刚", 21);
Student3 s5 = new Student3("吴问强", 23);
map1.put(s1, "打羽毛球");
map1.put(s2, "唱");
map1.put(s3, "跳");
map1.put(s4, "看美女");
map1.put(s5, "打游戏");
System.out.println("map1: " + map1);
}
}
============================================================
/*
"aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:
"a(5)b(4)c(3)d(2)e(1)"
*/
public class TreeMapTest1 {
public static void main(String[] args) {
String s1 = "aababcabcdabcde";
TreeMap<Character, Integer> map1 = new TreeMap<>();
//将字符串转字符数组
char[] chars = s1.toCharArray();
//遍历字符数组向集合中添加
for (char c : chars) {
if (map1.containsKey(c)) {
map1.put(c, map1.get(c) + 1);
} else {
map1.put(c, 1);
}
}
StringBuilder sb = new StringBuilder();
Set<Map.Entry<Character, Integer>> entries = map1.entrySet();
for (Map.Entry<Character, Integer> entry : entries) {
Character c = entry.getKey();
Integer count = entry.getValue();
sb.append(c).append("(").append(count).append(")");
}
String resStr = sb.toString();
System.out.println("结果为：" + resStr);
}
}
HashMap和Hashtable的区别
List,Set,Map等接口是否都继承子Map接口
标签：list1,
System,
println,
add,
集合,
public,
out
From： https://www.cnblogs.com/snzjz/p/18475650