Java自学第6期——Collection、Map、迭代器、泛型、可变参数、集合工具类、集合数据结构、Debug
欢迎访问我的个人网站:https://bengtian.club
集合:集合是java中提供的一种容器,可以用来存储多个数据。
集合和数组既然都是容器,它们有啥区别呢?
- 数组的长度是固定的。集合的长度是可变的。
- 数组中存储的是同一类型的元素,可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。
- 在开发中一般当对象多的时候,使用集合进行存储。
集合按照其存储结构可以分为两大类,分别是
单列集合java.util.Collection
和双列集合java.util.Map
,
综述:
根接 口 | Collection | Map |
---|---|---|
子接口 | List、Set | 未学 |
实现类 | Vector、LinkedList、ArrayList,HashSet、TreeSet | HashMap |
再子类 | LinkedHashSet | LinkedHashMap |
一、Collection接口
- Collection:单列集合类的根接口,用于存储一系列符合某种规则的元素,它有两个重要的子接口,
- 分别是
java.util.List
和java.util.Set
。 - 其中,
List
的特点是元素有序、元素可重复。 Set
的特点是元素无序,而且不可重复。List
接口的主要实现类有java.util.ArrayList
和java.util.LinkedList
,Set
接口的主要实现类有java.util.HashSet
和java.util.TreeSet
。- Collection没有索引,不能直接遍历,先转换成数组
Collection是所有单列集合的父接口,因此在Collection中定义了单列集合(List和Set)通用的一些方法,
这些方法可用于操作所有的单列集合。方法如下:
public boolean add(E e)
: 把给定的对象添加到当前集合中 。可以不用接收public void clear()
:清空集合中所有的元素。public boolean remove(E e)
: 把给定的对象在当前集合中删除。public boolean contains(E e)
: 判断当前集合中是否包含给定的对象。public boolean isEmpty()
: 判断当前集合是否为空。public int size()
: 返回集合中元素的个数。public Object[] toArray()
: 把集合中的元素,存储到数组中。
public static void main(String[] args) {//多态,接口指向实现类//此处ArrayList改成HashSet等其他集合也可以,方法一样Collection<String> collection1 = new ArrayList<>();
// Collection<String> collection1 = new HashSet<>();//打印空,不是地址,说明重写了toString方法System.out.println(collection1);collection1.add("kiana");//打印[kiana]System.out.println(collection1);collection1.add("bronya");collection1.add("Fuka");//[kiana, bronya, Fuka]System.out.println(collection1);collection1.remove("bronya");//[kiana, Fuka]System.out.println(collection1);//判断有无元素Meiboolean criticalResult = collection1.contains("Mei");//falseSystem.out.println(criticalResult);//判断集合是否为空boolean Result2 = collection1.isEmpty();//falseSystem.out.println(Result2);int sizeResult = collection1.size();//2System.out.println(sizeResult);//把集合变成数组Object[] array = collection1.toArray();//遍历数组,kiana Fukafor (int i = 0; i <array.length ; i++) {System.out.println(array[i]);}//删除集合元素,集合本身还在collection1.clear();//输出[]System.out.println(collection1);}
二、迭代器
Iterator迭代器,是Collection集合通用的取出元素的方式,先判断集合有没有元素,有就取出一个元素,再继续判断有没有元素……直到把集合中所有元素全部取出。这种取出方式称作迭代。
boolean hasNext():(判断)如果仍有元素可以迭代,则返回 true。
E next():(取出)返回迭代的下一个元素。
void remove():从迭代器指向的 collection 中移除迭代器返回的最后一个元素(可选操作)。
Iterator是接口 不能直接使用,需要接口的实现类。注意,Iterator接口也是有泛型的,与集合相同。Collection接口里有个方法:
iterator() ,返回的就是Iterator的实现类对象。
Iterator iterator(): 返回在此 collection 的元素上进行迭代的迭代器。
public static void main(String[] args) {Collection<String> collection1 = new ArrayList<>();collection1.add("板鸭");collection1.add("芽衣");//[板鸭, 芽衣]System.out.println(collection1);//第一步,获取这个集合的迭代器。接口指向实现类对象Iterator<String> iterator = collection1.iterator();//第二步,判断有没有元素System.out.println(iterator.hasNext());//第三步,取出元素String next = iterator.next();//板鸭System.out.println(next);//trueSystem.out.println(iterator.hasNext());//芽衣System.out.println(iterator.next());//已经没有元素了,再取会抛出NoSuchElementException没有元素异常
// System.out.println(iterator.next());//优化Collection<String> collection2 = new ArrayList<>();collection2.add("板鸭");collection2.add("芽衣");Iterator<String> iterator1 = collection2.iterator();//板鸭芽衣while(iterator1.hasNext()){System.out.print(iterator1.next());}}
三、泛型
- 泛型:一种未知的数据类型,定义集合时若暂未确定集合内元素类型,可使用泛型。
- 泛型也可以看作是一个变量,用来接收数据类型。
- E e:Element 元素
- T t:Type 类型
- 创建集合对象的时候,就会确认泛型的数据类型
*不使用泛型时,默认Object类型,可以存储任意类型的数据。坏处:不安全,会引发异常。 - 好处:避免了类型转换的麻烦;把运行期异常,提升到了编译期。
public static void main(String[] args) {method1();method2();}/*创建集合对象,不使用泛型时,默认Object类型,可以存储任意类型的数据。坏处:不安全,会引发异常。*/private static void method1(){ArrayList array1 = new ArrayList();//创建集合array1.add("女武神");//存储字符串array1.add(12);//存储整数//使用迭代器遍历Iterator iterator1 = array1.iterator();while(iterator1.hasNext()){Object obj1 = iterator1.next();System.out.println(obj1);//输出:女武神 12//假如要使用String类里的lenghth()输出字符串长度,// 需要把Object类型的obj1向下转型为String类型String string1 = (String)obj1;System.out.println(string1.length());//3//上面产生了ClassCastException类型转换异常,这就是不使用泛型的缺点}}private static void method2(){ArrayList<String> list = new ArrayList<>();list.add("Valkyrie");Iterator<String> iterator2 = list.iterator();while(iterator2.hasNext()){System.out.println(iterator2.next());}}
- 定义一个含有泛型的数据类型,模拟ArrayList集合。
- 泛型可以接收任意的数据类型,可以使用Integer,String、Object……
- 创建对象的时候确定泛型的数据类型。
- 不写泛型默认是Object类型
//添加泛型E:
public class Demo05_class<E> {private E name;public E getName() {return name;}public void setName(E name) {this.name = name;}
}
- 测试类
对象类写成泛型,不把它写死,要什么类型就在创建对象的时候定义
*/
public class Demo05_class1 {public static void main(String[] args) {//不写泛型默认是Object类型Demo05_class obj = new Demo05_class();obj.setName("字符串");//创建Demo05_class对象,使用Integer泛型Demo05_class<Integer> obj2 = new Demo05_class<>();obj2.setName(123);System.out.println(obj2.getName());//使用含有泛型的方法Demo05_method obj3 = new Demo05_method();//传递什么类型,泛型就是什么类型obj3.method1("666");//Stringobj3.method1(666);//Integer//静态方法通过类名点方法名直接使用。Demo05_method.method2("666");//创建接口实现类对象方法1Demo05_InterfaceImpl obj4 = new Demo05_InterfaceImpl();obj4.method4("888");//创建接口实现类对象方法2,在创建对象时确认泛型Demo05_InterfaceImpl2<String> obj5 = new Demo05_InterfaceImpl2();obj5.method4("字符串");}
- 定义接口的实现类,指定接口的泛型
public interface Iterator<E>{E next();
}
public class Demo05_InterfaceImpl implements Demo05_Interface<String> {@Overridepublic void method4(String i){System.out.println(i);}
}
- 接口和实现类后都写上泛型, 重写时泛型作为参数进入方法
public class Demo05_InterfaceImpl2<I> implements Demo05_Interface<I> {@Overridepublic void method4(I i){System.out.println("重写2");}}
- 定义含有泛型的方法:
泛型定义在方法的修饰符和返回值之间,参数列表里可以通过泛型使用
在调用方法的时候确认泛型的使用类型
public class Demo05_method {public <E> void method1(E one) {System.out.println(one);}//定义一个含有泛型的静态方法public static <S> void method2(S s){System.out.println("含有泛型的静态方法");}
}
- 泛型通配符<?>在参数传递的时候使用
public static void main(String[] args) {ArrayList<String> list1 = new ArrayList<>();list1.add("字符串");ArrayList<Integer> list2 = new ArrayList<>();list2.add(666);//该方法能同时调用不同类型的集合method1(list1);//字符串method1(list2);//666}//泛型通配符在参数传递的时候使用public static void method1(ArrayList<?> list){Iterator<?> iterator1 = list.iterator();while(iterator1.hasNext()){System.out.println(iterator1.next());}}
斗地主案例实现
public static void main(String[] args) {//定义存储54张牌的ArrayList集合ArrayList<String> array1 = new ArrayList<>();//定义两个数组,一个存储花色,一个存储序号String[] colors = {"黑桃","红桃","方块","梅花"};String[] nubers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};//集合里存储大王小王array1.add("大王");array1.add("小王");//循环嵌套两个数组,组装52张牌for (String numbers:nubers){for (String colours : colors) {//System.out.println(colours+numbers);//把组装好的牌存储到集合中array1.add(colours+numbers);}}
// System.out.println(array1);//洗牌,通过Collections里的shuffle方法Collections.shuffle(array1);
// System.out.println(array1);//定义四个集合,存储玩家的牌ArrayList<String> play01 = new ArrayList<>();ArrayList<String> play02 = new ArrayList<>();ArrayList<String> play03 = new ArrayList<>();ArrayList<String> dipai = new ArrayList<>();//发牌System.out.println(array1.size());for (int i = 0; i < array1.size() ; i++) {//获取每一张牌String str1 = array1.get(i);if ( i>=51){//底牌dipai.add(str1);}else if (i%3==0){//玩家1发牌play01.add(str1);}else if (i%3==1){//玩家2发牌play02.add(str1);}else if (i%3==2){//玩家3发牌play03.add(str1);}}//看牌System.out.println("1号:" + play01);System.out.println("2号:" + play02);System.out.println("3号:" + play03);System.out.println("底牌:"+ dipai);}
四、List接口
Collection下一个List一个Set。
List集合下的实现类中,ArrayList查找快,增删慢;LinkedList是List借口的链表实现,查询慢,增删快。
import java.util.List;
- List:有序集合(存取顺序相同),有索引,允许存储重复元素。底层是数组。此实现是多线程,非同步。
- 方法:
boolean add(E e)
向列表的尾部添加指定的元素(可选操作)。
void add(int index, E element)
在列表的指定位置插入指定元素(可选操作)。
E get(int index)
返回列表中指定位置的元素。
ListIterator listIterator()
返回此列表元素的列表迭代器(按适当顺序)。
ListIterator istIterator(int index)
返回列表中元素的列表迭代器(按适当顺序),从列表的指定位置开始。
E remove(int index)
移除列表中指定位置的元素(可选操作)。
boolean remove(Object o)
从此列表中移除第一次出现的指定元素(如果存在)(可选操作)。
public static void main(String[] args) {//多态List<String> list1 = new ArrayList<>();list1.add("光");list1.add("翼");list1.add("展");list1.add("开");list1.add(0,"kiana");System.out.println(list1.get(0));//kianaListIterator<String> listIterator1 = list1.listIterator();ListIterator<String> listIterator2 = list1.listIterator(1);while(listIterator1.hasNext()){System.out.println(listIterator1.next());//kiana 光 翼 展 开}while(listIterator2.hasNext()){System.out.println(listIterator2.next());//光翼展开}list1.remove(0);System.out.println(list1);//[光, 翼, 展, 开]list1.remove("光");System.out.println(list1);//[翼, 展, 开]}
实现类LinkedList
- LinkedList集合查询慢,增删快,含有大量用于修改首尾的方法。
如果使用LinkedList特有的方法,则不能使用多态 - 方法:
void addFirst(E e):
将指定元素插入此列表的开头。
void addLast(E e):
将指定元素添加到此列表的结尾。
void clear():
从此列表中移除所有元素。
boolean contains(Object o):
如果此列表包含指定元素,则返回 true。
E get(int index):
返回此列表中指定位置处的元素。
E getFirst():
返回此列表的第一个元素。
E getLast():
返回此列表的最后一个元素。
E removeFirst():
移除并返回此列表的第一个元素。
E removeLast():
移除并返回此列表的最后一个元素。
public static void main(String[] args) {LinkedList<String> list1 = new LinkedList<>();list1.add("kiana");list1.addFirst("love");list1.addLast("is me");System.out.println(list1);//[love, kiana, is me]System.out.println(list1.get(1));//kianaif (list1.contains("love")){System.out.println("含有lova");}list1.removeFirst();System.out.println(list1);//[kiana, is me]}
- Vector集合,实现可增长的对象数组,底层是数组,已经被ArrayList取代,单线程
五、Set接口
Collection的另一个孩子,
1.不能存储重复元素。
2.没有索引,不能使用普通的for循环遍历。
3.底层是哈希表结构,查询速度很快,存取元素顺序可能不一致。
4.HashSet集合类实现Set接口;
- 方法:
boolean add(E e):
如果 set 中尚未存在指定的元素,则添加此元素(可选操作)。
boolean addAll(Collection<? extends E> c):
如果 set 中没有指定 collection 中的所有元素,则将其添加到此 set 中(可选操作)。
void clear():
移除此 set 中的所有元素(可选操作)。
boolean contains(Object o):
如果 set 包含指定的元素,则返回 true。
boolean containsAll(Collection<?> c):
如果此 set 包含指定 collection 的所有元素,则返回 true。
boolean equals(Object o):
比较指定对象与此 set 的相等性。
int hashCode():
返回 set 的哈希码值。
boolean isEmpty():
如果 set 不包含元素,则返回 true。
Iterator iterator():
返回在此 set 中的元素上进行迭代的迭代器。
boolean remove(Object o):
如果 set 中存在指定的元素,则将其移除(可选操作)。
boolean removeAll(Collection<?> c):
移除 set 中那些包含在指定 collection 中的元素(可选操作)。
boolean retainAll(Collection<?> c):
仅保留 set 中那些包含在指定 collection 中的元素(可选操作)。
int size():
返回 set 中的元素数(其容量)。
Object[] toArray():
返回一个包含 set 中所有元素的数组。
T[] toArray(T[] a):
返回一个包含此 set 中所有元素的数组;返回数组的运行时类型是指定数组的类型。
public static void main(String[] args) {Set<String> setList1 = new HashSet<>();setList1.add("Mei");setList1.add("逐火之蛾");setList1.add("Mei");//重复元素存储失败System.out.println(setList1.contains("Mei"));Iterator<String> iterator1 = setList1.iterator();while (iterator1.hasNext()){System.out.println(iterator1.next());}System.out.println(setList1.size());
HashSet实现类
- 哈希值是一个十进制的整数,由系统随机给出。
Object类的hashCode方法返回对象的哈希码值:
int hashCode()
jdk1.8之后,哈希表=数组+红黑树(加快查询速度)
存储数据到集合中,首先计算元素的哈希值 - 没有重写时,HashSet比较的是两个对象的地址值,
存储自定义类型的元素时必须重写hashCode和equals方法同时比较元素和哈希值更稳妥。
按Alt+Insert重写方法
@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Demo11_Hash that = (Demo11_Hash) o;return Objects.equals(name, that.name) &&Objects.equals(age, that.age);}
@Overridepublic int hashCode() {return super.hashCode();}
LinkedHashSet(继承HashSet)
- 具有可预知迭代顺序的Set接口的哈希表和链表实现
LinkedHashSet集合extends了HashSet集合,
LinkedHashSet集合底层是哈希表(链表+数组/红黑树)+链表,多的链表用来记录元素存储顺序,保证元素有序
public static void main(String[] args) {HashSet<String> set1 = new HashSet<>();set1.add("a");set1.add("a");set1.add("c");set1.add("b");System.out.println(set1);//[a, b, c],无重复,无顺序LinkedHashSet<String> linkedset2 = new LinkedHashSet<>();linkedset2.add("a");linkedset2.add("a");linkedset2.add("c");linkedset2.add("b");System.out.println(linkedset2);//[a, c, b],有顺序,无重复}
六、可变参数
- 可变参数:当方法的参数列表数据类型已经确定,但参数的数据类型不确定,就可以使用可变参数
使用格式:定义方法时使用
修饰符 返回值类型 方法名(数据类型…变量名){}
原理:可变参数底层是数组,根据传递参数个数不同,会创建不同长度的数组,来存储这些参数。
传递的参数个数可以是0个(不传递),1,2,3…很多个。
可变参数的终极写法:
(Object…obj) - 注意:
一个方法的参数列表,只能有一个可变参数。
如果方法的参数有多个,那么可变参数必须写在参数列表的末尾。
public static void main(String[] args) {Sum1();System.out.println(Sum2(222,111,223,3));//559Sum3(33,"w",3.14);}//定义一个方法,计算两个int整数的和public static void Sum1(){System.out.println("请输入俩数字");Scanner num1 = new Scanner(System.in);Scanner num2 = new Scanner(System.in);int sum = num1.nextInt()+num2.nextInt();System.out.println(sum);}//计算未定数目的参数的和public static int Sum2(int...num3){int Sum= 0;for (int i : num3) {Sum += i;}return Sum;}public static void Sum3(Object...obj){for (Object o : obj) {System.out.println(o);}}
七、Collections工具类
Collections工具类:java.utils.Collections
- 方法:
public static boolean addAll(Collection c,T…elements)
往集合中添加多个元素
public static void shuffle(List list)
打乱集合顺序
public static void sort(List list)
将集合中的元素按照默认顺序排序
public static void sort(List list,Comparator <? super T>)
将集合中的元素按照指定规则排序 - 注:被排序的集合里的元素,必须实现Comparable接口,重写接口中的compareTo定义排序的规则
public static void main(String[] args) {ArrayList<String> list1 = new ArrayList<>();//addAllCollections.addAll(list1,"k","i","a","n","a");System.out.println("addAll:"+list1);//shuffleCollections.shuffle(list1);System.out.println("打乱后:"+list1);//sort默认(数字默认大小升序,字符串默认自然升序abcdefg...)Collections.sort(list1);System.out.println("默认排序后:"+list1);//[a, a, i, k, n]//sort指定,重写排序规则ArrayList<Integer> list2 = new ArrayList<>();list2.add(1);list2.add(3);list2.add(2);Collections.sort(list2, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {//o1-o2代表升序,o2-o1代表降序return o1-o2;}});System.out.println(list2);//1,2,3//自定义类型Demo00_Person的排列ArrayList<Demo00_Person> list3 = new ArrayList<>();list3.add(new Demo00_Person("琪亚娜",17));list3.add(new Demo00_Person("芽衣",18));list3.add(new Demo00_Person("板鸭",15));list3.add(new Demo00_Person("舰长",20));System.out.println("自定义类型排列前:"+list3);Collections.sort(list3, new Comparator<Demo00_Person>() {@Overridepublic int compare(Demo00_Person o1, Demo00_Person o2) {//先按年龄排列int result = o1.getAge() - o2.getAge();//如果年龄相同,按照名字排列if(result == 0){result = o1.getName().charAt(0)-o2.getName().charAt(0);}return result;}});System.out.println("自定义类型排列后:"+list3);
八、集合数据结构
和集合相关的数据结构:栈、队列,数组,链表,红黑树。
- 栈:先进后出
元素存储到集合中时,先存储的元素在栈的底部,后进入的元素在栈的顶部,
取出元素时,先取出栈顶部的元素,栈底部的元素后取出。栈的出口和入口相同。
例如:入栈顺序123,出栈的顺序即为321。
- 队列:先进先出
入口和出口不同,先入者接近出口,后入者离出口较远。
- 数组:查询快,增删慢。
查询快:数组的地址是连续的,通过首地址找到数组,再通过索引找到想要的数组元素。
增删慢:数组的长度是固定的,增删数组需要创建一个新的数组,并将源数组的数据复制到新数组中。
源数组在内存中被销毁(垃圾回收)。
- 链表(linked list):由一系列节点node(链表中的元素)组成,节点在运行时动态生成。
每个节点包含一个存储数据元素的数据域,和两个分别存储自己和下一个节点地址的指针域。
链表结构通常有单向链表和双向链表。多个节点间通过地址相连。 - 单向链表:链表中只有一条链子,不能保证元素的顺序。存储、取出的数据可能不一致。
- 双向链表:有两条链子,其中一条专门记录元素的顺序,所是一个有序的集合.
查询慢:想查找某个元素,需要通过连接的节点,一次向后查找指定元素。地址不连续,每次查询需要从头开始。
增删快:增删元素对链表整体结构没有影响,所以快。
- 红黑树:
二叉树:分支不能超过两格的树
排序树/查找树:在二叉树的基础上,元素是有大小的,左子树小,右子树大
红黑树:节点红色或黑色,根节点黑色,叶子节点黑色,每个红色的节点的子节点都是黑色,任何节点到其
每一个叶子节点的所有路径上黑色节点的数量是相同的。
九、Map集合接口
java里集合除了Collections(List/Set)外就是Map集合,用来存放映射关系的对象。
- Collection中的集合,元素是孤立存在的(理解为单身),向集合中存储元素采用一个个元素的方式存储。
- Map 中的集合,元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成,通过键可以找对所对应的值。
- Collection 中的集合称为单列集合, Map 中的集合称为双列集合。
需要注意的是, Map 中的集合不能包含重复的键,值可以重复;每个键只能对应一个值。 - java.util.Map<k,v> :key键,value值,通过key可以找到对应的value,
value可以重复,一个key对应一个value,key不可以重复。
key和map数据类型可以相同可以不同,
靠key维护他们之间的关系。
HashMap:
Map的两个常用子类:HashMap和LinkedHashMap
- HashMap:存储数据采用的哈希表结构,元素的存取顺序不能保证一致。
由于要保证键的唯一、不重复,需 要重写键的hashCode()方法、equals()方法。 - LinkedHashMap:HashMap下有个子类LinkedHashMap,存储数据采用的哈希表结构+链表结构。
通过链表结构可以保证元素的存取顺序一致;通过哈希表结构可以保证的键的唯一、不重复,
需要重写键的 hashCode()方法、equals()方法。
tips:Map接口中的集合都有两个泛型变量,在使用时,要为两个泛型变量赋予数据类型。
两个泛型变量的数 据类型可以相同,也可以不同。
tips:Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。
Map接口中定义了很多方法,常用的如下:
public V put(K key, V value) : 把指定的键与指定的值添加到Map集合中。
public V remove(Object key) : 把指定的键 所对应的键值对元素 在Map集合中删除,返回被删除元素的值。
public V get(Object key) 根据指定的键,在Map集合中获取对应的值。
public Set keySet() : 获取Map集合中所有的键,存储到Set集合中。
public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。
public static void main(String[] args) {HashMap<Integer,String> list1 = new HashMap<>();list1.put(0,"kiana");list1.put(1,"love");list1.put(2,"me");//kianaSystem.out.println(list1.get(0));boolean b = list1.containsKey(5);//falseSystem.out.println(b);//遍历Map集合,先取出key到set集合,再用Iterator或者增强forSet<Integer> setlist1 = list1.keySet();Iterator<Integer> iterator = setlist1.iterator();while (iterator.hasNext()){Integer key = iterator.next();String value = list1.get(key);System.out.println(key+" 对应 "+value);}for (Integer key1 : setlist1){//此处setList1可以直接写List1.keySet简化一步System.out.println(list1.get(key1));}
Entry:
Map 中存放的是两种对象,一种称为key(键),一种称为value(值),
它们在在 Map 中是一一对应关系,这一对对象又称做 Map 中的一个 Entry(项)
Entry 将键值对的对应关系封装成了对象。
即键值对对象,这样我们在
遍历 Map 集合时,就可以从每一个键值对( Entry )对象中获取对应的键与对应的值。
既然Entry表示了一对键和值,那么也同样提供了
- 获取对应键和对应值的方法:
public K getKey() :获取Entry对象中的键。
public V getValue() :获取Entry对象中的值。
在Map集合中也提供了 - 获取所有Entry对象的方法:
public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。
public static void main(String[] args) {HashMap<Integer,String> list2 = new HashMap<>();//添加三个entry对象list2.put(1,"1");list2.put(2,"2");list2.put(3,"3");//获取entry对象到set集合中Set<Map.Entry<Integer, String>> obj1 = list2.entrySet();//增强for遍历set集合,集合里通过getKey、getValue方法活动对象的键值for (Map.Entry<Integer, String> integerStringEntry : obj1) {Integer key = integerStringEntry.getKey();String value = integerStringEntry.getValue();System.out.println(key+value);//11,22,33}
- Map集合存储自定义类型的方法:
当给HashMap中存放自定义对象时,
如果自定义对象作为key存在,
这时要保证对象唯一,必须复写对象的 hashCode和equals方法.
如果要保证map中存放的key和取出的顺序一致,可以使用 java.util.LinkedHashMap 集合来存放。
public static void main(String[] args) {//key写为自定义类型HashMap<Dem00_Person,String> map1 = new HashMap<>();//创建自定义对象为参数:map1.put(new Dem00_Person("Kiana",16),"大老婆");map1.put(new Dem00_Person("Mei",17),"二老婆");map1.put(new Dem00_Person("Bronya",14),"三老婆");map1.put(new Dem00_Person("Teresa",12),"小老婆");//取出元素,键找值方式,注意Set类型写法Set<Map.Entry<Dem00_Person,String>> obj2 = map1.entrySet();
集合工厂方法 of():
- JDK9对集合添加元素的优化:
通常,我们在代码中创建一个集合(例如,List 或 Set ),并直接用一些元素填充它。
实例化集合,几个 add方法 调用,代码显得重复。
Java 9,添加了几种集合工厂方法,更方便创建少量元素的集合、map实例。
新的List、Set、Map的静态工厂方法of可以更方便地创建集合的不可变实例。 - 使用前提:
1.集合中元素的数确定且不再改变
2.只适用于List、Set、Map接口,不适用于它们的实现类;
3.Set和Map存的元素不能有重复,List可以
public static void main(String[] args) {List<String> list1 = List.of("k","i","a","n","a","a");
// list1.add("aa");
// UnsupportedOperationException不支持操作异常,of返回的集合不可再改变
// Set<String> set1 = Set.of("a", "a");
// Set集合存储重复元素,抛出IllegalArgumentException非法参数异常}
十、Debug
IDEA中:
左边设置断点,右键选择Debug运行程序,程序停止在了断点行不再运行
Debug后,下方按钮从左到右:
- Console:切换到控制台
- Step Over(F8):代码向下执行一行
- Step Into(F7):进入要调用的方法
- Step Out(shift + F8):跳出方法
左边: - Resume Program(F9):调到下一个断点
- Stop(Ctrl+F2):停止调试的程序,退出Debug模式
Java自学第6期——Collection、Map、迭代器、泛型、可变参数、集合工具类、集合数据结构、Debug相关推荐
- Day18JavaSE——Map集合Collections工具类集合案例练习
Day18JavaSE--Map集合&Collections工具类&集合案例练习 文章目录 Day18JavaSE--Map集合&Collections工具类&集合案例 ...
- 小汤学编程之JAVA基础day11——集合框架:List/Set/Map集合、Collections集合工具类、泛型、TreeMap和TreeSet
一.集合的特点 二.继承结构图 三.List集合 1.特点 2.ArrayList类 3.LinkedList类 4.两者的对比 5.集合的遍历 四.Set集合 1.特 ...
- Java集合篇:Map接口、Map接口的实现类、Collections集合工具类
目录 一.Map接口 1.1 Map接口概述 1.2 Map接口常用功能 二.Map接口的实现类 2.1 Map实现类之一:HashMap 2.1.1 HashMap概述 2.1.2 HashMap的 ...
- 【小白学Java】D26 》》》Collections集合工具类
[友情链接]---–->Java中的各种集合大汇总,学习整理 [友情链接]----–> collection集合 [友情链接]----–> ArrayList集合及其常用功能 [友情 ...
- [Google Guava] 2.3-强大的集合工具类:java.util.Collections中未包含的集合工具
原文链接 译文链接 译者:沈义扬,校对:丁一 尚未完成: Queues, Tables工具类 任何对JDK集合框架有经验的程序员都熟悉和喜欢java.util.Collections包含的工具方法.G ...
- Java中集合相关案例(泛型通配符、Collections工具类、TreeSet、TreeMap、HashMap、HashSet和集合嵌套案例)
集合 一.集合相关案例 1.泛型通配符案例 2.集合工具类(Collections工具类) 3.TreeSet和TreeMap案例 4.HashMap案例 5.HashSet案例 6.TreeSet案 ...
- 总结的一些json格式和对象/String/Map/List等的互转工具类
总结的一些json格式和对象/String/Map/List等的互转工具类,有需要的可以看看,需要引入jackson-core-asl-1.7.1.jar.jackson-jaxrs-1.7.1.ja ...
- java 集合反射_关于granite源码包CollectionUtil集合工具类获取集合反射类型、实例化各种集合类型HashSet/ArrayList等...
一.前言 基于granite源码包org.granite.util.CollectionUtil集合工具类,分别获取集合反射类型java.lang.reflect.Type.实例化newCollect ...
- java list排序工具类_java 之 Collections集合工具类排序
数组有工具类Arrays,集合也有一个工具类Collections. sort方法: sort(List list):根据其元素natural ordering对制定的列表进行排序 sort(List ...
最新文章
- 中英文最大AI模型世界纪录产生,大模型竞赛新阶段来了
- 理解 Cinder 架构 - 每天5分钟玩转 OpenStack(45)
- 公钥密码--Paillier
- vue中怎么点击修改文字_Vue.js点击切换按钮改变内容
- PHP下kafka的实践(已经测试)
- click vue 重复调用_VUE防止多次点击,重复请求
- ASP.NET 开发者 开始学习ASP.NET Core 2吧
- 获取freemarker处理后的内容
- linux php mysql 中文_Linux下PHP+MySQL+CoreSeek中文检索引擎配置 | 系统运维
- 微信退款参数格式错误
- Solr基础,在Eclipse中运行Solr
- 兮米安装包制作工具图文教程集锦电子书
- 在线教育市场为何因“最强雾霾”得利?
- 基于ResNet迁移学习的LFW人脸识别分类
- java使用oshi获取硬件信息,包括cpu温度
- arm开发板无法使用dns解析问题
- UG NX 10 草图基础知识和概念
- 【JS Web 前端知识库】6.说一说BFC
- 【收藏】前端开发必备:前端开发不得不收藏的网站,提高200%开发效率!
- shell 获取当月最后一天的方法
热门文章
- 2022年度总结 - 明月醉窗台
- 智力题库软件测试,最新软件测试笔试题网友回忆版
- 对话华纳前CEO西尔弗曼:如何成功打造电影《神奇女侠》
- 双色球号码生成和验证
- c语言一维数组字符串数组初始化,一维数组的定义、初始化和引用
- mac每次执行mvn -v命令要先执行source ~/.bash_profile才生效
- python之pandas初级使用案例(2)对数据的访问和操作
- flash服务器停止响应,shockwave flash 未响应解决方法,shockwave flash已经崩溃解决方法...
- 京浜光电IPO被终止:曾拟募资7.1亿 实控人已改为日本籍
- vue版本的仿京东放大镜代码还有原生js版本的。(组件封装)