浅学 “ Java常见STL ”
Collection集合常用功能
public static void main(String[] args){
Collection<String> coll=new ArrayList<>();
//向集合中添加元素
coll.add("hello");
coll.add("zhong");
coll.add("guo");
System.out.println(coll);
//删除集合中的某个元素
boolean r=coll.remove("hello");
System.out.println(coll);
//清空集合
coll.clear();
System.out.println(coll);
//判断集合中是否包含某个元素
boolean f=coll.contains("guo");
System.out.println(f);
//判断集合是否为空
System.out.println(coll.isEmpty());
//获取集合的长度
System.out.println(coll.size());
//将集合转成一个数组
Object[] arr = coll.toArray();
for(int i=0;i<arr.length;i++)
System.out.println(arr[i]);
}
Iterator迭代器
Iterator接口也是Java集合中的一员,但它与Collection、Map接口有所不同
Collection接口与Map接口主要用于存储元素,而Iterator主要用于 迭代访问(即遍历) Collection中的元素,因此Iterator对象也被称为迭代器
那么迭代是什么意思?
即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素,如果有,就把这个元素取出来,继续在判断,如果还有就再取出来,一直把集合中的所有元素全部取出
Iterator接口
public static void main(String[] args){
Collection<String> coll= new ArrayList<>();
coll.add("AAA");
coll.add("BBB");
coll.add("CCC");
coll.add("DDD");
coll.add("EEE");
coll.add("FFF");
Iterator<String> it=coll.iterator();
//判断还有没有下一个元素,有则返回true
//boolean b=it.hasNext();
//System.out.println(b);//true
//String s =it.next();
//System.out.println(s);//AAA
//boolean b1=it.hasNext();
//System.out.println(b1);//true
//String s1 =it.next();
//System.out.println(s1);//BBB
//上面的输出方法太麻烦了,
//循环结束的条件是:hasNext方法返回false
//迭代方法遍历
while(it.hasNext())
{
String e=it.next();
System.out.println(e);
}
//for循环遍历
for(Iterator<String> it2=coll.iterator();it2.hasNext();){
String e=it2.next();
System.out.println(e);
}
}
LinkedList集合
Set集合存储元素不重复的原理
HashSet存储自定义类型元素
//实现同名同年龄的人只能存储一次
//必须重写hashCode方法和equals方法
public static void main(String[] args){
//创建HashSet集合存储person
HashSet<person> s=new HashSet<>();
person p=new person("张三",18);
person p1=new person("张三",18);
person p2=new person("王五",22);
System.out.println(p.hashCode());//764977973
System.out.println(p1.hashCode());//381259350
System.out.println(p1==p);//false 哈希值不同
System.out.println(p.equals(p1));//false
s.add(p);
s.add(p1);
s.add(p2);
System.out.println(s);
}
public class person extends Object{
private String name;
private int age;
public person() {
}
public person(String name, int age) {
this.name = name;
this.age = age;
}
//添加下面这段代码,重写hashCode方法和equals方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
person person = (person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "person{" +
"name='" + name + '\'' +
", 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;
}
LinkedHashSet集合
/*
LinkedHashSet集合extends HashSet集合
LinkedHashSet集合特点:
底层是一个哈希表(数组+链表/红黑树)+链表:多了一条链表(记录元素的存储顺序),保证元素有序
*/
public static void main(String[] args){
//创建HashSet集合存储person
HashSet<String> s=new HashSet<>();
s.add("abc");
s.add("abc");
s.add("hello");
s.add("world");
System.out.println(s);//[abc, world, hello] 无序 不允许重复
LinkedHashSet<String> s1=new LinkedHashSet<>();
s1.add("abc");
s1.add("abc");
s1.add("hello");
s1.add("world");
System.out.println(s1);//[abc, hello, world]有序 不允许重复
可变参数
/*
可变参数
使用前提
当方法的参数列表数据类型已经确定,但是参数的个数不确定,就可以使用可变参数
使用格式
修饰符 返回值类型 方法名(数据类型...变量名){}
可变参数的原理:
底层是一个数组,根据传递参数个数不同,创建不同长度的数组,传递的参数可以是任意个
注意
一个方法的参数列表只能有一个可变参数
如果方法的参数有多个,那么可变参数必须写在参数列表的末尾
*/
public static void main(String[] args) {
int i=add(1,2,3,4,5,6,7,8,9,10);
System.out.println(i);
}
public static int add(int...arr){
int ans=0;
for(int i:arr)
{
ans+=i;
}
return ans;
}
//可变参数的终极写法,可以传入任意类型的参数
public static void method(Object...obj){
}
Collections集合常用功能
注意这个是Collections(+s的哦),和前面的是不一样的
/*
Comparator和Comparable的区别
Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
Comparator:相当于找一个第三方裁判,比较两个
*/
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
/* list.add("a");
list.add("b");
list.add("c");
System.out.println(list);//[a, b, c]
*/
//如果需要存大量数据
Collections.addAll(list,"a","b","c");
System.out.println(list);//[a, b, c]
//打乱集合顺序Integer
Collections.shuffle(list);
System.out.println(list);//[c, b, a]
ArrayList<Integer> list1 = new ArrayList<>();
Collections.addAll(list1,1,5,6,2,4,7,8,9);
//默认是从小到大
Collections.sort(list1);
System.out.println(list1);//[1, 2, 4, 5, 6, 7, 8, 9]
//
ArrayList<person> list2 = new ArrayList<>();
list2.add(new person("张三",21));
list2.add(new person("李四",20));
list2.add(new person("王五",19));
System.out.println(list2);
//sort使用前提
//该排序的集合里面存储的元素,必须实现Comparable,重写接口中的方法compareTo定义排序的规则
//Comparable排序
//return this.getAge()-o.getAge();//年龄从小到大
//return o.getAge()-this.getAge();//年龄从大到小
Collections.sort(list2);
System.out.println(list2);
ArrayList<Integer> list3 = new ArrayList<>();
list3.add(3);
list3.add(4);
list3.add(1);
list3.add(2);
System.out.println(list3);
Collections.sort(list3, new Comparator<Integer>() {
//重写比较的规则
@Override
public int compare(Integer t1, Integer t2) {
// return 0;
// return t1-t2;//升序
return t2-t1;//降序
}
});
System.out.println(list3);
}
public class person implements Comparable<person>{
private String name;
private int age;
public person() {
}
@Override
public String toString() {
return "person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public person(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(person o) {
//return 0;
//return this.getAge()-o.getAge();//年龄从小到大
return o.getAge()-this.getAge();//年龄从大到小
}
}
Map集合
Map<K,V> ,k-此映射所维护的键的类型 ,v-映射值的类型
一个映射不能包含重复的键,每个键最多只能映射到一个值
Map集合的特点:
1.Map集合是一个双列集合,一个元素包含两个值(一个key,一个value)
2.Map集合中的元素,key与value的数据类型可以相同,也可以不同
3.Map集合中的元素,key不允许重复,value可以重复
4.Map集合中的元素,key与value一一对应
HashMap特点:
- HashMap底层是哈希表,查询速度快
jdk1.8前,数组+单向链表
jdk1.8后,数组+单向链表/红黑树(链表长度超过8变为红黑树)
2.HahsMap集合是一个无序的集合,存储元素和取出元素的顺序可能不一致
LinkedMap特点:
1.LinkedHashMap集合底层是哈希表+链表
2.LinkedHashMap集合是一个有序的结合,存储元素和取出元素的顺序一致
public static void main(String[] args) {
demo01();//put:把指定的键与指定的值添加到Map集合中
demo02();//remove:把指定的键所对应的键值对元素在map集合中删除
demo03();//containsKey:判断结合中是否包含指定的键
demo04();//get:根据指定的键,在map集合中获取对应的值
}
public static void demo01(){
//put操作
Map<String,String> map=new HashMap<>();
//存储键值对的时候,key不重复,返回值v是null
//存储键值对的时候,key重复,会使用新的value替换map中重复的value,返回被替换的value值
String str = map.put("张三", "李四");
System.out.println(str);//null
String str1 = map.put("张三", "李四123");
System.out.println(str1);//李四
System.out.println(map);//{张三=李四123}
map.put("王五","赵六");
map.put("a","c");
map.put("b","c");
System.out.println(map);//{a=c, 张三=李四123, b=c, 王五=赵六}
}
public static void demo02(){
//remove操作
//key存在,v返回被删除的值
//key不存在,v返回null;
Map<String,Integer> map=new HashMap<>();
map.put("x",1);
map.put("y",2);
map.put("z",3);
Integer x1 = map.remove("x");
System.out.println(x1);//1
Integer x2 = map.remove("a");
System.out.println(x2);//null
System.out.println(map);//{y=2, z=3}
}
public static void demo03(){
//containsKey操作
//key存在,返回true
//key不存在,返回false;
Map<String,Integer> map=new HashMap<>();
map.put("x",1);
map.put("y",2);
map.put("z",3);
boolean y1=map.containsKey("x");
System.out.println(y1);//true
boolean y2=map.containsKey("a");
System.out.println(y2);//false
}
public static void demo04(){
//get操作
//key存在,返回v
//key不存在,返回null;
Map<String,Integer> map=new HashMap<>();
map.put("x",1);
map.put("y",2);
map.put("z",3);
Integer z1=map.get("x");
System.out.println(z1);//1
Integer z2=map.get("a");
System.out.println(z2);//null
}
Map集合的遍历方式
//keyset用法
public static void main(String[] args) {
Map<String,Integer> map=new HashMap<>();
map.put("x",1);
map.put("y",2);
map.put("z",3);
Set<String> set= map.keySet();
//使用迭代器
Iterator<String> it = set.iterator();
while(it.hasNext()){
String key=it.next();
Integer value=map.get(key);
System.out.println(key+"="+value);
}
//使用增强for
for(String key:set){
Integer value=map.get(key);
System.out.println(key+"="+value);
}
//增强for简化版
for(String key:map.keySet()){
Integer value=map.get(key);
System.out.println(key+"="+value);
}
}
//EntrySet用法
/*
Map集合的第二种遍历方式:使用Entry对象遍历
Map集合中的方法:
set<Map.Entry<K,V>> entryset() 返回此映射中包含的键的set视图
实现步骤:
1.使用Map集合的方法entryset(),把Map集合多个yEntr取出来,存储到一个set集合中
2.遍历set集合,获取每一个Entry对象
3.使用Entry对象中的方法getkey()和getValue()获取键与值
*/
public static void main(String[] args) {
Map<String,Integer> map=new HashMap<>();
map.put("x",1);
map.put("y",2);
map.put("z",3);
Set<Map.Entry<String, Integer>> set = map.entrySet();
// Set<String> set= map.keySet();
//使用迭代器
Iterator<Map.Entry<String,Integer>> it = set.iterator();
while(it.hasNext()){
Map.Entry<String, Integer> nx = it.next();
String key = nx.getKey();
Integer value = nx.getValue();
System.out.println(key+"="+value);
}
//使用增强for
for(Map.Entry<String,Integer> entry:set){
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"="+value);
}
}
Hashtable集合
/*
Hashtable :底层是哈希表,不能存储null值,null键
*/
public static void main(String[] args) {
HashMap<String,String> mp=new HashMap<>();
mp.put(null,"a");// 这种情况存储不进去但不会报错
mp.put("b",null);
mp.put(null,null);
System.out.println(mp);
Hashtable<String,String> table=new Hashtable<>();
table.put("1","a");
table.put("b","2");
// table.put(null,null);//这种情况会报错
System.out.println(table);
}
JDK9对集合添加元素的优化—of方法
/*
list接口、Set接口、Map接口,里面增加了一个静态的方法of,可以给集合一次性添加多个元素
使用前提:
当集合中存储的元素的个数已经确定了,不在改变时使用
注意:
of方法只适用于list接口、set接口、Map接口,不适用于接接口的实现类
of方法的返回值是一个不能改变的集合,集合不能在使用add,put方法添加元素,会抛出异常
set接口和Map接口在调用of方法的时候,不能有重复的元素,否则会抛出异常
*/
public static void main(String[] args) {
List<String> a = List.of("a", "b", "c");
System.out.println(a);
//Set<String> b = Set.of("1","1" ,"2", "3");//错误,不可重复
Set<String> b = Set.of("1" ,"2", "3");
System.out.println(b);
//Map<String, String> x = Map.of("x", "1", "y", "2","x","3");//x重复
Map<String, String> x = Map.of("x", "1", "y", "2");
System.out.println(x);
}
版权声明:本文为Piink原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。