写点什么

Java 集合

用户头像
anuyyy
关注
发布于: 2021 年 04 月 03 日
Java 集合框架图

由上图可以看出,Java 集合框架主要包括两种类型的容器:

  • 集合(Collection):存储一个元素集合

  • 图(Map):存储键/值对映射


集合接口

Collection 接口:Java 不提供直接继承自 Collection 的类,只提供继承于的子接口(如 List 和 set)。

Collection 接口存储一组不唯一,无序的对象。

List 接口:List 接口是一个有序的 Collection,使用此接口能够精确的控制每个元素插入的位置

能够通过索引(元素在 List 中位置,类似于数组的下标)来访问 List 中的元素,第一个元素的索引为 0,而且允许有相同的元素。

List 接口存储一组不唯一,有序(插入顺序,存储和取出的顺序一致)的对象

Set 接口:Set 具有与 Collection 完全一样的接口,只是行为上不同,Set 不保存重复的元素。

Set 接口存储一组唯一,无序的对象。

Map 接口:Map 接口存储一组键值对象,提供 key(键)到 value(值)的映射。


Collection 的使用

package Collection常用方法;
import java.util.ArrayList;import java.util.Collection;
/* 创建Collection集合的对象: 使用多态和ArrayList()的方式 */public class CollectionTest { public static void main(String[] args) { //创建Collection集合的对象 Collection<String> c=new ArrayList<String>();
//添加元素:boolean add(E e) c.add("yyy"); c.add("aaa");
//输出集合对象 System.out.println(c); }}
复制代码


Collection 的常用方法

package Collection常用方法;
import java.util.ArrayList;import java.util.Collection;
public class CollectionTest2 { public static void main(String[] args) { //创建集合对象 Collection<String> c=new ArrayList<String>();

//boolean add(E e);添加元素,可以存储重复元素 System.out.println(c.add("yyy")); System.out.println(c.add("yyy")); System.out.println(c.add("aaa")); //Alt+7可以打开一个窗口,能够看到类的所有信息 c.add("yyy"); c.add("java"); c.add("abc");
//boolean remove(Object o);从集合中移除指定的元素 System.out.println(c.remove("yyy")); //true System.out.println(c.remove("yyyy")); //false
//void clear();清空集合中的所有元素 c.clear();
//boolean contains(Object o);判断集合中是否存在指定的元素 System.out.println(c.contains("yyy")); //true System.out.println(c.contains("yyyy")); //false
//boolean isEmpty();判断集合是否为空 System.out.println(c.isEmpty());
//int size();集合的长度,也就是集合中元素的个数 System.out.println(c.size());
//输出集合对象 System.out.println(c); }}
复制代码


Collection 集合的遍历

package Collection遍历;
import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;
/* Iterator:迭代器,集合的专用遍历方式 Iterator<E> iterator(); 返回此集合中元素的迭代器,通过集合的iterator()方法得到 迭代器是通过集合的iterator()方法得到的,所以我们说它是依赖于集合而存在的
Iterator中的常用方法: E next(); 返回迭代中的下一个元素 boolean hasNext(); 如果迭代具有更多元素,则返回true */public class IteratorTest { public static void main(String[] args) { //创建集合对象 Collection<String> c=new ArrayList<String>();
//添加元素 c.add("aaa"); c.add("bbb"); c.add("ccc");
//Iterator<E> iterator(); 返回此集合中元素的迭代器,通过集合的iterator()方法得到 Iterator<String> it = c.iterator();
//E next(); 返回迭代中的下一个元素 System.out.println(it.next()); System.out.println(it.next()); System.out.println(it.next()); //System.out.println(it.next());出现异常 NoSuchElementException:表示被请求的元素不存在
//boolean hasNext(); 如果迭代具有更多元素,则返回true /* if(it.hasNext()){ System.out.println(it.next()); } if(it.hasNext()){ System.out.println(it.next()); } if(it.hasNext()){ System.out.println(it.next()); } if(it.hasNext()){ System.out.println(it.next()); } //在判断中没有下一个元素也不会报错
*/
//用while循环改进判断 while (it.hasNext()){ //System.out.println(it.next()); String s = it.next();//一般先拿到it.next();的值,然后Ctrl+Alt+v System.out.println(s);//输出元素 } }}
复制代码


List 集合的特点

package LIst常用方法;
import java.util.ArrayList;import java.util.Iterator;import java.util.List;
/* List集合的特点: 有序:存储和取出的元素顺序一致 可重复:存储的元素可以重复 */public class ListTest { public static void main(String[] args) { //创建集合对象 List<String> list=new ArrayList<String>();
//添加元素 list.add("aaa"); list.add("bbb"); list.add("ccc"); list.add("ccc");
//输出集合对象 //System.out.println(list);
//采用迭代器的方法进行遍历 Iterator<String> it = list.iterator(); while(it.hasNext()){ String next = it.next(); System.out.println(next); } }
}
复制代码


List 集合的特有方法

package LIst常用方法;
import java.util.ArrayList;import java.util.Collection;import java.util.List;
/* List集合特有方法 void add(int index,E element) 在此集合中的指定位置插入指定的元素 E remove(int index) 删除指定索引处的元素,返回被删除的元素 E set(int index,E element) 修改指定索引处的元素,返回被修改的元素 E get(int index) 返回指定索引处的元素 */public class ListTest2 { public static void main(String[] args) { //创建集合对象 List<String> list=new ArrayList<String>();
//添加元素 list.add("aaa"); list.add("bbb"); list.add("ccc");
//void add(int index,E element) 在此集合中的指定位置插入指定的元素 list.add(1,"yyy");//在索引1的位置插入yyy //list.add(11,"yyy");IndexOutOfBoundsException:索引越界异常
//E remove(int index) 删除指定索引处的元素,返回被删除的元素 System.out.println(list.remove(1)); //System.out.println(list.remove(11));索引越界异常
//E set(int index,E element) 修改指定索引处的元素,返回被修改的元素 System.out.println(list.set(1,"abc")); //System.out.println(list.set(1,"abc"));索引越界异常
//E get(int index) 返回指定索引处的元素 System.out.println(list.get(1)); //System.out.println(list.get(11));索引越界异常
//输出集合对象 //System.out.println(list);
//遍历集合方式二,使用for循环 for (int i = 0; i < list.size(); i++) { String s = list.get(i); System.out.println(s); }
}}
复制代码


列表迭代器

package List列表迭代器;
import java.util.ArrayList;import java.util.List;import java.util.ListIterator;
/* ListIterator:列表迭代器 通过List集合的listIterator()方法得到。所以说它是List集合特有的迭代器 用于允许程序员沿任一方向遍历列表的列表的迭代器,在迭代期间修改列表,并获取列表中迭代器的当前位置
ListIterator中的常用方法: E next();返回迭代中的下一个元素 boolean hasNext();如果迭代具有更多元素,则返回true E previous();返回列表中的上一个元素 boolean hasPrevious();如果此列表迭代器在相反方向遍历列表时具有更远元素,则返回true void add(E e);将指定的元素插入列表
*/public class ListIteratorTest { public static void main(String[] args) { List<String> list=new ArrayList<String>();
list.add("aaa"); list.add("bbb"); list.add("xxx");
//通过List集合的listIterator()方法得到 ListIterator<String> sit = list.listIterator(); while (sit.hasNext()){ String next = sit.next(); System.out.println(next); } System.out.println("------");
//逆向遍历 while(sit.hasPrevious()){ String previous = sit.previous();//E previous();返回列表中的上一个元素 System.out.println(previous); }
//通过列表迭代器来添加元素 ListIterator<String> lit=list.listIterator(); while (lit.hasNext()){ String next = lit.next(); if(next.equals("aaa")){ lit.add("ccc"); } } System.out.println(list);
}}
复制代码


增强 for 循环

package List增强for循环;
import java.util.ArrayList;import java.util.List;
/* 增强for:简化数组和Collection集合的遍历 实现Iterable接口的类允许其对象成为增强型for语句的目标 它是JDK5之后出现的额,其内部原理是一个Iterator迭代器 格式: for(元素数据类型 变量名:数组或者Collection集合){ //在此处使用变量即可,该变量就是元素 } */public class ForTest { public static void main(String[] args) { int[] arr={1,2,3,4,5}; for (int i :arr) { System.out.println(i); } System.out.println("------");
String[] strArray={"bbb","vvv","aaa"}; for(String s:strArray){ System.out.println(s); } System.out.println("------");
List<String> list=new ArrayList<String>(); list.add("iii"); list.add("ppp"); list.add("uuu"); for(String a:list){ System.out.println(a); } System.out.println("------");
//验证:其内部原理是一个Iterator迭代器 for(String s:list){ if(s.equals("ppp")){ list.add("yyy");//ConcurrentModificationException 抛出异常,由此为true } } }}
复制代码


List 集合子类的特点(包含了三种遍历方法)

package List集合子类的特点;
import java.util.ArrayList;import java.util.Iterator;import java.util.LinkedList;
/* List集合常用子类:ArrayList,LinkedList ArrayList:底层数据结构是数组,查询块,增删慢 LinkedList:底层数据结构是链表,查询慢,增删快
练习: 分别使用ArrayList和LinkedList完成存储字符串并使用三种遍历 */public class Test { public static void main(String[] args) { //使用ArrayList实现 ArrayList<String> array=new ArrayList<String>();
array.add("yyy"); array.add("vvv"); array.add("uuu");
for (int i = 0; i <array.size() ; i++) { String s = array.get(i); System.out.println(s); }
System.out.println("--------");
for(String a:array){ System.out.println(a); }
System.out.println("--------");
Iterator<String> it = array.iterator(); while (it.hasNext()){ String next = it.next(); System.out.println(next); }
System.out.println("--------");
//使用LinkedList实现 LinkedList<String> linkedList=new LinkedList<String>();
linkedList.add("sb"); linkedList.add("sb2"); linkedList.add("sb3");
for (int i = 0; i <linkedList.size() ; i++) { String s = linkedList.get(i); System.out.println(s); }
System.out.println("--------");
for(String a:linkedList){ System.out.println(a); }
System.out.println("--------");
Iterator<String> it2 = linkedList.iterator(); while (it2.hasNext()){ String next = it2.next(); System.out.println(next); } }}
复制代码


LinkList 集合的特有功能

package LinkedList集合的特有功能;
import java.util.LinkedList;
/* LinkedList集合的特有功能: public void addFirst(E e);在该列表开头插入指定的元素 public void addLast(E e);将指定的元素追加到此列表的末尾
public E getFirst();返回此列表中的第一个元素 public E getLast();返回此列表中的最后一个元素
public E removeFirst();从此列表中删除并返回第一个元素 public E removeLast();从此列表中删除并返回最后一个元素 */public class Test { public static void main(String[] args) { LinkedList<String> linkedList=new LinkedList<String>();
linkedList.add("hello"); linkedList.add("world"); linkedList.add("java");
// public void addFirst(E e);在该列表开头插入指定的元素// public void addLast(E e);将指定的元素追加到此列表的末尾 linkedList.addFirst("javase"); linkedList.addLast("javaee");
// public E getFirst();返回此列表中的第一个元素// public E getLast();返回此列表中的最后一个元素 System.out.println(linkedList.getFirst()); System.out.println(linkedList.getLast());
// public E removeFirst();从此列表中删除并返回第一个元素// public E removeLast();从此列表中删除并返回最后一个元素 System.out.println(linkedList.removeFirst()); System.out.println(linkedList.removeLast());
System.out.println(linkedList); }}
复制代码


Set 集合的特点与遍历

package Set集合遍历;
import java.util.HashSet;import java.util.Iterator;import java.util.Set;
/* Set集合特点: 不包含重复元素的集合 没有带索引的方法,所以不能使用普通for循环遍历
HashSet:对集合的迭代顺序不作任何保证 */public class Test { public static void main(String[] args) { Set<String> set=new HashSet<String>();
set.add("hello"); set.add("world"); set.add("java");
for(String s:set){ System.out.println(s); }
System.out.println("_______");
Iterator<String> it = set.iterator(); while(it.hasNext()){ String next = it.next(); System.out.println(next); } }}
复制代码


哈希值


package 哈希值;
import java.util.Objects;
public class Student { public String name; public int age;
public Student() { }
public Student(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; }
//重写hashCode方法 @Override public int hashCode() { return 666; }}
package 哈希值;/* 哈希值: 是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
Object类中有一个方法可以获取对象的哈希值 public int hashCode();返回对象的哈希码值 */public class test { public static void main(String[] args) { Student s1=new Student("yyy",17);
//同一个对象多次调用hasCode()方法返回的哈希值是相同的 System.out.println(s1.hashCode());//793589513 System.out.println(s1.hashCode());//793589513
System.out.println("--------");
//默认情况下,不同对象的哈希值是不相同的 //但是通过方法重写,可以实现不同对象的哈希值相同 Student s2=new Student("yyy",17); System.out.println(s2.hashCode());//1313922862
System.out.println("--------");
System.out.println("hello".hashCode());//99162322 System.out.println("world".hashCode());//113318802 System.out.println("java".hashCode());//3254818
System.out.println("java".hashCode());//3254818 System.out.println("--------");
System.out.println("哦哦".equals("鹅鹅鹅"));//使用equals对比两个字符串,如果相同返回true,不同返回false System.out.println("哦哦".hashCode());//如果为true,那么hasCode绝对相同 System.out.println("鹅鹅鹅".hashCode());
System.out.println("--------");
System.out.println("好好".equals("好好")); //true System.out.println("好好".hashCode()); //733088 System.out.println("好好".hashCode()); //733088
System.out.println("--------");
System.out.println("重地".equals("通话")); //hashCode相同,但是值不一定相同 System.out.println("重地".hashCode()); //不同对象的hashCode可能相同 System.out.println("通话".hashCode());
}}
复制代码


HashSet 集合的特点

HashSet 基于 HashMap 来实现的,是一个不允许有重复元素的集合。

HashSet 允许有 null 值。

HashSet 是无序的,即不会记录插入的顺序。


package HashSet集合特点;
import java.util.HashSet;import java.util.Iterator;
/* HashSet集合特点: 1,底层数据结构是哈希表 2,对集合的迭代顺序不作任何保证,也就是说不保证存储和取出的元素顺序一致 3,没有带索引的方法,所以不能使用普通for循环遍历 4,由于是set集合,所以是不包含重复元素的集合 */public class Test { public static void main(String[] args) { HashSet<String> hs=new HashSet<String>();
hs.add("hello"); hs.add("world"); hs.add("java");
for(String s:hs){ System.out.println(s); }
System.out.println("---------");
Iterator<String> it = hs.iterator(); while(it.hasNext()){ String next = it.next(); System.out.println(next); } }}
复制代码


LinkedHashSet 集合的特点

LinkedHashSet 是 Set 集合的一个实现,具有 set 集合不重复的特点,同时具有可预测的迭代顺序,也就是我们插入的顺序

package LinkedHashSet集合的特点;
import java.util.LinkedHashSet;
/* LinkedHashSet集合特点: 1,哈希表和链表实现的Set接口,具有可预测的迭代次序 2,由链表保证元素有序,也就是说元素的存储和取出顺序是一致的 3,由哈希表保证元素唯一,也就是说没有重复的元素 */public class Test { public static void main(String[] args) { LinkedHashSet<String> linkedHashSet=new LinkedHashSet<String>();
linkedHashSet.add("hello"); linkedHashSet.add("world"); linkedHashSet.add("java");
linkedHashSet.add("java");
for(String s:linkedHashSet){ System.out.println(s); } }}
复制代码


TreeSet 集合的特点

package TreeSet集合特点;
import java.util.TreeSet;
/* TreeSet集合特点: 1,元素有序,这里的顺序不是值存储和取出的顺序,而是按照一定的规则进行排序,具体排序方式取决于构造方法 TreeSet();根据其元素的自然排序进行排序 TreeSet(Comparator comparator);根据指定的比较器进行排序 2,没有带索引的方法,索引不能使用普通for循环遍历 3,由于是Set集合,所以不包含重复元素的集合 */public class Test { public static void main(String[] args) { TreeSet<Integer> ts=new TreeSet<Integer>();//无参,按照自然排序
ts.add(10); ts.add(90); ts.add(40);
ts.add(40);
for(Integer i:ts){ System.out.println(i); } }}
复制代码


自然排序 Comparable 的使用:

Comparable 是一个接口

package 自然排序Comparable的使用;
public class Student implements Comparable<Student>{ public String name; public int age;
public Student() { }
public Student(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 int compareTo(Student s) { //return 0;//重复元素,不添加 //return 2;//返回值为正数,就会按照升序来存储 //return -2;//返回值是负数,就会按照降序来存储
//按照年龄从小到大排序 //s1不需要比较,从s2开始比较,所以s.age表示s1 int num=this.age-s.age;//从小到大 //int num=s.age-this.age;//从大到小
//年龄相同时,按照姓名的字母顺序排序 int num2=num==0?this.name.compareTo(s.name):num;//compareTo比较 return num2; }}
package 自然排序Comparable的使用;
import java.util.TreeSet;
/*TreeSet集合可以让元素排序,并且可以去除重复元素
存储学生对象并遍历,创建集合使用无参构造方法 要求: 按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序 */public class Test { public static void main(String[] args) { TreeSet<Student> ts=new TreeSet<Student>();
Student s1=new Student("yyy",17); Student s2=new Student("aaa",19); Student s3=new Student("uuu",10);
Student s4=new Student("ppp",10);//年龄重复,s4的age-s3的age为0,
ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4);
for(Student s:ts){ System.out.println(s.getName()+","+s.getAge()); } }}
复制代码


比较器 comparator 排序

有些自定义类的 List 序列,当这个对象不支持自比较或者自比较函数不能满足你的要求时,你可以写一个比较器来完成两个对象之间大小的比较,也就是指定使用 Comparator(临时规则排序,也称作专门规则排序)

package 比较器排序Comparator使用;
public class Student { public String name; public int age;
public Student() { }
public Student(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; }}
package 比较器排序Comparator使用;
import java.util.Comparator;import java.util.TreeSet;
/* 存储学生对象并遍历,创建TreeSet集合使用带参构造方法 要求: 按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序 */public class Test { public static void main(String[] args) { TreeSet<Student> ts=new TreeSet<Student>(new Comparator<Student>() { @Override public int compare(Student s1, Student s2) { int num=s1.getAge()-s2.getAge(); int num2=num==0?s1.getName().compareTo(s2.getName()):num; return num2; } });
Student s1=new Student("yyy",17); Student s2=new Student("aaa",19); Student s3=new Student("uuu",16);
ts.add(s1); ts.add(s2); ts.add(s3);
for(Student s:ts){ System.out.println(s.getName()+","+s.getAge()); }
}}
复制代码


泛型

泛型的好处:将运行时的异常提前到了编译期

泛型类:

泛型类的声明和非泛型类的声明类似,除了在类名后面添加了类型参数声明部分。

和泛型方法一样,泛型类的类型参数声明部分也包含一个或多个类型参数,参数间用逗号隔开

实例:

package 泛型类;
public class Generic<T> { public T t;
public T getT() { return t; }
public void setT(T t) { this.t = t; }}
package 泛型类;
public class Student { public String name;
public String getName() { return name; }
public void setName(String name) { this.name = name; }}
package 泛型类;
public class Teacher { public int age;
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }}
package 泛型类;
public class Test { public static void main(String[] args) { Student s=new Student(); s.setName("yyy"); System.out.println(s.getName());
Teacher t=new Teacher(); t.setAge(25); System.out.println(t.getAge());
System.out.println("------------");
//使用泛型类 Generic<String> g1=new Generic<String>(); g1.setT("yyy"); System.out.println(g1.getT());
Generic<Integer> g2=new Generic<Integer>(); g2.setT(18); System.out.println(g2.getT());
Generic<Boolean> g3=new Generic<Boolean>(); g3.setT(true); System.out.println(g3.getT()); }}
复制代码


泛型方法:

定义泛型方法,其格式是:修饰符 <类型参数列表> 返回类型 方法名(形参列表) { 方法体 }。

实例:

package 泛型方法;
//public class Generic {// public void show(String s){// System.out.println(s);// }//// public void show(Integer i){// System.out.println(i);// }//// public void show(Boolean b){// System.out.println(b);// }//}
//使用泛型类改进//public class Generic<T> {// public void show(T t){// System.out.println(t);// }//}
//使用泛型方法改进public class Generic<T> { public<T> void show(T t){ System.out.println(t); }}
package 泛型方法;
public class Test { public static void main(String[] args) {// Generic g=new Generic();// g.show("yyy");// g.show(true);// g.show(15);
// Generic<String> g1=new Generic<String>();// g1.show("yyy");//// Generic<Integer> g2=new Generic<Integer>();// g2.show(18);//// Generic<Boolean> g3=new Generic<Boolean>();// g3.show(true);
Generic g=new Generic(); g.show("yyy"); g.show(18); g.show(true); }}
复制代码


泛型接口:

访问权限 interface 接口名<泛型标示>{}

实例:

package 泛型接口;
public interface Generic<T> { public void show(T t);}
package 泛型接口;
public class GenericImpl<T> implements Generic<T> { @Override public void show(T t) { System.out.println(t); }}
package 泛型接口;
public class test { public static void main(String[] args) { Generic<String> g1=new GenericImpl<String>(); g1.show("yyy");
Generic<Integer> g2=new GenericImpl<Integer>(); g2.show(17); }}
复制代码


类型通配符

package 类型通配符;
import java.util.ArrayList;import java.util.List;
/* 类型通配符:<?> List<?>:表示元素类型未知的List,它的元素可以匹配任何的类型 这种带通配符的List仅表示它是各种泛型List的父类,并不能把元素添加到其中
类型通配符上限:<? extends 类型> List<? extends Number>:它表示的类型是Number或者其子类型
类型通配符下线:<? super 类型> List<? super Number>:它表示的类型是Number或者其父类型 */public class Test { public static void main(String[] args) { //类型通配符:<?> List<?> list1=new ArrayList<Object>(); List<?> list2=new ArrayList<Number>(); List<?> list3=new ArrayList<Integer>(); System.out.println("----------------");
//类型通配符上限:<? extends 类型> 上限是Number,就是最大的就是Number //List<? extends Number> list4=new ArrayList<Object>(); List<? extends Number> list5=new ArrayList<Number>(); List<? extends Number> list6=new ArrayList<Integer>(); System.out.println("----------------");
//类型通配符下线:<? super 类型> 下限是Number,就是最小的就是Number List<? super Number> list7=new ArrayList<Object>(); List<? super Number> list8=new ArrayList<Number>(); //List<? super Number> list9=new ArrayList<Integer>(); }}
复制代码

可变参数

格式:修饰符 返回值类型 方法名(数据类型...变量名){}


package 可变参数;
public class Test1 { public static void main(String[] args) { System.out.println(sum(20,30)); System.out.println(sum(20,30,40)); }
// public static int sum(int b,int...a){// return 0;//如果一个参数有多个参数,包含可变参数,可变参数要放在最后// }
//使用可变参数 public static int sum(int...a){// System.out.println(a);// return 0;//[I@b4c966a 是一个int类型的数组 int sum=0; for(int i:a){ sum+=i; } return sum; }
// public static int sum(int a,int b){// return a+b;// }// public static int sum(int a,int b,int c){// return a+b+c;// }}
package 可变参数;
import java.util.Arrays;import java.util.List;import java.util.Set;
/* Arrays工具类中有一个静态方法: public static <T> List<T> asList(T...a);返回由指定数组支持的固定大小的列表
List接口中有一个静态方法: public static <E> List<E> of(E...elements);返回包含任意数量元素的不可变列表
Set接口中有一个静态方法: public static <E> Set<E> of(E...elements);返回一个包含任意数量元素的不可变集合 */public class Test2 { public static void main(String[] args) { //public static <T> List<T> asList(T...a);返回由指定数组支持的固定大小的列表 //List<String> list = Arrays.asList("yyy", "aaa", "abc");
//list.add("uuu");//UnsupportedOperationException不支持该请求,会改变集合的大小 //list.remove("yyy");//UnsupportedOperationException不支持该请求,会改变集合的大小 //list.set(1,"uuu"); //System.out.println(list);
//public static <E> List<E> of(E...elements);返回包含任意数量元素的不可变列表 //List<String> list = List.of("yyy", "uuu", "ooo","ooo");//list集合可以有重复元素
//list.add("ppp");//nsupportedOperationException //list.remove("yyy");//nsupportedOperationException //list.set(1,"aaa");//nsupportedOperationException
//System.out.println(list);
//public static <E> Set<E> of(E...elements);返回一个包含任意数量元素的不可变集合 //Set<String> set = Set.of("aaa", "bbb", "ccc", "ccc");//IllegalArgumentException,Set集合不允许有重复元素 Set<String> set = Set.of("aaa", "bbb", "ccc");
//set.add("uuu");//UnsupportedOperationException //set.remove("bbb");//UnsupportedOperationException
System.out.println(set);
}}
复制代码


Map 集合

package Map集合;
import java.util.HashMap;import java.util.Map;
/* Map集合概述: Interface Map<K,V> K:键的类型 V:值得类型 将键映射到值得对象,不能包含重复的键,每个键可以映射到最多一个值
创建Map集合的对象 多态的方式 具体的实现类HashMap */public class Test { public static void main(String[] args) { Map<Integer,String> map=new HashMap<Integer,String>();
//V put(K key,V value) 将指定的值与该映射中的指定键相关联 map.put(1,"yyy");//put指往集合中添加元素 map.put(2,"aaa"); map.put(3,"bbb"); map.put(3,"bbb");//当键第二次出现时,就变成了修改元素,替代了上一个元素
System.out.println(map); }}
package Map集合;
import java.util.HashMap;import java.util.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();集合的长度,也就是集合中键值对的个数 */public class Test2 { public static void main(String[] args) { Map<Integer,String> map=new HashMap<Integer, String>();
//V put(K key,V value);添加元素 map.put(1,"yyy"); map.put(2,"uuu"); map.put(3,"ppp");
//V remove(Object key);根据键删除键值对元素// System.out.println(map.remove(1));//删除后返回该键的值// System.out.println(map.remove(8));//没有对应键时,返回null
//void clear();移除所有的键值对元素 //map.clear();
//boolean containsKey(Object key);判断集合是否包含指定的键 //System.out.println(map.containsKey(1)); System.out.println(map.containsKey(8));
//boolean containsValue(object value);判断集合是否包含指定的值 //System.out.println(map.containsValue("yyy"));
// boolean isEmpty();判断集合是否为空 //System.out.println(map.isEmpty());
//int size();集合的长度,也就是集合中键值对的个数 //System.out.println(map.size());
System.out.println(map);


}}
package Map集合;
import java.time.Instant;import java.util.Collection;import java.util.HashMap;import java.util.Map;import java.util.Set;
/* Map集合的获取功能: V get(Object key);根据键获取值 Set<K> keySet();获取所有键的集合 Collection<V> values();获取所有值得集合 */public class Test3 { public static void main(String[] args) { Map<Integer,String> map=new HashMap<Integer, String>();
map.put(1,"yyy"); map.put(2,"uuu"); map.put(3,"ppp");
//V get(Object key);根据键获取值// System.out.println(map.get(1));// System.out.println(map.get(8));//null
//Set<K> keySet();获取所有键的集合// Set<Integer> keySet = map.keySet();// for(Integer s:keySet){// System.out.println(s);// }
//Collection<V> values();获取所有值得集合 Collection<String> values = map.values(); for(String i:values){ System.out.println(i); }
}}
复制代码


Map 集合的遍历

package Map集合的遍历;
import java.util.HashMap;import java.util.Map;import java.util.Set;
/* Map集合遍历方式1: 1,获取所有键的集合,用keySet()方法实现 2,遍历键的集合,获取到每一个键,用增强for实现 3,根据键去找值,用get(Object key)方法实现 */public class Test { public static void main(String[] args) { Map<Integer,String> map=new HashMap<Integer, String>();
map.put(1,"yyy"); map.put(2,"uuu"); map.put(3,"ppp");
Set<Integer> keySet = map.keySet(); for (Integer i:keySet){ //根据键去找值,用get(Object key)方法实现 String s = map.get(i); System.out.println(i+","+s); }
}}
package Map集合的遍历;
import java.util.HashMap;import java.util.Map;import java.util.Set;
/* Map集合遍历方式2: 1,获取所有键值对对象的集合 Set<Map.Entry<K,V>> entrySet();获取所有键值对对象的集合 2,遍历键值对对象的集合,得到每一个键值对对象 用增强for实现,得到每一个Map.Entry 3,根据键值对对象获取键和值 用getKey()得到键 用getValue()得到值 */public class Test2 { public static void main(String[] args) { Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "yyy"); map.put(2, "uuu"); map.put(3, "ppp");
//获取所有键值对对象的集合 Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
//遍历键值对对象的集合,得到每一个键值对对象 for (Map.Entry<Integer, String> me : entrySet) { //根据键值对对象获取键和值 Integer key = me.getKey(); String value = me.getValue(); System.out.println(key + "," + value); } }}
复制代码


Collections 的使用

package Collections的使用;
import java.util.ArrayList;import java.util.Collections;import java.util.List;
/* Collections类的概述:是针对集合操作的工具类 collections类的常用方法: public static <T extends Comparable<? super T>> void sort(List<T> list);将指定的列表按升序排序 public static void reverse (List<?> list);反转指定列表中元素的顺序 public static void shuffle(List<?> list);使用默认的随机源随机排列指定的列表 */public class Test { public static void main(String[] args) { List<Integer> list=new ArrayList<Integer>();
list.add(10); list.add(40); list.add(20); list.add(50); list.add(60);
//public static <T extends Comparable<? super T>> void sort(List<T> list);将指定的列表按升序排序 //Collections.sort(list);//升序,从小到大
//public static void reverse (List<?> list);反转指定列表中元素的顺序 //Collections.reverse(list);//顺序倒过来
//public static void shuffle(List<?> list);使用默认的随机源随机排列指定的列表 Collections.shuffle(list);//随机,每个数的出现的位置的可能性相同
System.out.println(list); }}
复制代码


发布于: 2021 年 04 月 03 日阅读数: 19
用户头像

anuyyy

关注

还未添加个人签名 2021.03.23 加入

还未添加个人简介

评论

发布
暂无评论
Java 集合