Collection接口是构造集合框架的基础,定义了操作对象集合的共同方法。 List接口是有序,可包含重复元素的列表。 Set接口是无序的,无重复元素的集合的列表。
package com.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
public class CollectionTest1 {
public static void main(String[] args) {
//有序,重复,有索引
Collection c=new ArrayList();
c.add("a");
c.add("a");
c.add("b");
c.add("c");
c.add("d");
c.add("d");
System.out.println(c); //[a, a, b, c, d, d]
//无序,不重复,无索引
Collection c1=new HashSet();
c1.add("a");
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");
c1.add("d");
System.out.println(c1); //[a, b, c, d]
}
}
案例:
package com.collection;
import java.util.ArrayList;
import java.util.Collection;
public class Collection_API {
public static void main(String[] args) {
Collection<String> c=new ArrayList<>();
//添加元素
c.add("小马哥");
c.add("小飞侠");
c.add("罗西");
c.add("马奎斯");
c.add("罗西");
System.out.println(c); //[小马哥, 小飞侠, 罗西, 马奎斯, 罗西]
//获取集合大小
System.out.println(c.size()); //5
//判断集合是否为空
System.out.println(c.isEmpty()); //false
// System.out.println(c);
//判断集合中是否包含某个元素
System.out.println(c.contains("小马哥")); //true
//删除某个元素,如果是重复元素,则删除第一个
System.out.println(c.remove("罗西")); //true
System.out.println(c); //[小马哥, 小飞侠, 马奎斯, 罗西]
//把集合转换为数组
Object o=c.toString();
System.out.println(o); //[小马哥, 小飞侠, 马奎斯, 罗西]
//清空集合元素
c.clear();
System.out.println(c); //[]
//将集合c2中的元素倒入c1中
Collection<String> c1=new ArrayList<>();
c1.add("a");
c1.add("b");
c1.add("c");
Collection<String> c2=new ArrayList<>();
c2.add("d");
c2.add("e");
c2.add("f");
c2.add("g");
c1.addAll(c2);
System.out.println(c1); //[a, b, c, d, e, f, g]
}
}
1.Iterator迭代器
案例:
package com.collection.iterator;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
//collection集合遍历方式
public class IteratorTest {
public static void main(String[] args) {
//iterator遍历
//创建Collection集合对象
Collection<String> c=new ArrayList<>();
//添加元素
c.add("小马哥");
c.add("小飞侠");
c.add("罗西");
c.add("马奎斯");
c.add("罗西");
//得到迭代器对象
Iterator<String> it = c.iterator();
//循环遍历
while (it.hasNext()){
System.out.println(it.next());
}
}
}
/* 小马哥 小飞侠 罗西 马奎斯 罗西 */
2.增强for循环遍历
案例:
package com.collection;
import java.util.ArrayList;
import java.util.Collection;
//增强for遍历
public class ForTest {
public static void main(String[] args) {
Collection<String> c=new ArrayList<>();
//添加元素
c.add("小马哥");
c.add("小飞侠");
c.add("罗西");
c.add("马奎斯");
c.add("罗西");
for (String s : c) {
System.out.println(s);
}
}
}
/* 小马哥 小飞侠 罗西 马奎斯 罗西 */
3.案例分析
package com.collection.Test;
public class Student {
private String name;
private int age;
private double height;
public Student() {
}
public Student(String name, int age, double height) {
this.name = name;
this.age = age;
this.height = height;
}
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;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", height=" + height +
'}';
}
}
package com.collection.Test;
import java.util.ArrayList;
import java.util.Collection;
public class StudentTest {
public static void main(String[] args) {
Collection<Student> students=new ArrayList<>();
students.add(new Student("小马哥",34,180.5));
students.add(new Student("小飞侠",44,170.5));
students.add(new Student("马奎斯",24,190.5));
students.add(new Student("罗西",54,189.5));
for (Student student : students) {
System.out.println(student.getName()+"\t"+student.getAge()+"\t"+student.getHeight());
}
}
}
/* 小马哥 34 180.5 小飞侠 44 170.5 马奎斯 24 190.5 罗西 54 189.5 */
1.Arraylist类
案例:
package com.list;
import java.util.ArrayList;
import java.util.List;
public class ListTest {
public static void main(String[] args) {
//创建一个List集合对象
List<String> list=new ArrayList();
list.add("小马哥");
list.add("小飞侠");
list.add("马奎斯");
list.add("小马哥");
//在某个索引插入元素
list.add(1,"罗西");
System.out.println(list); //[小马哥, 罗西, 小飞侠, 马奎斯, 小马哥]
//根据索引删除元素
list.remove(1);
System.out.println(list); //[小马哥, 小飞侠, 马奎斯, 小马哥]
//根据索引获取元素
System.out.println(list.get(2)); //马奎斯
//修改某索引的元素
list.set(1,"科比");
System.out.println(list); //[小马哥, 科比, 马奎斯, 小马哥]
}
}
2.List遍历方式
package com.list;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
//List遍历方式
public class ListTest2 {
public static void main(String[] args) {
List<String> list=new ArrayList();
list.add("小马哥");
list.add("小飞侠");
list.add("马奎斯");
list.add("小马哥");
//for循环
for (int i = 0; i <list.size() ; i++) {
String s = list.get(i);
System.out.println(s);
}
System.out.println();
//iterator迭代器
Iterator<String> it = list.iterator();
while (it.hasNext()){
String s = it.next();
System.out.println(s);
}
System.out.println();
//增强for循环
for (String s : list) {
System.out.println(s);
}
}
}
/* 小马哥 小飞侠 马奎斯 小马哥 小马哥 小飞侠 马奎斯 小马哥 小马哥 小飞侠 马奎斯 小马哥 */
3.List遍历删除相同元素
package com.list;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
//遍历删除相同元素
public class ListTest3 {
public static void main(String[] args) {
List<String> list=new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
System.out.println(list); //[a, b, b, c, d, e]
//迭代器删除元素
/* Iterator<String> it = list.iterator(); while (it.hasNext()){ String s = it.next(); if ("b".equals(s)){ it.remove(); //使用迭代器删除保证不后移 } } System.out.println(list); //[a, c, d, e]*/
//for循环删除元素(方式一)
/*for (int i = 0; i <list.size() ; i++) { String s = list.get(i); if ("b".equals(s)){ list.remove("b"); i--; } } System.out.println(list); //[a, c, d, e]*/
//for循环删除元素(方式二)
for (int i =list.size()-1; i >=0 ; i--) {
String s = list.get(i);
if ("b".equals(s)){
list.remove("b");
}
}
System.out.println(list); //[a, c, d, e]
}
}
4.LinkedList类
package com.list;
import java.util.LinkedList;
public class LinkedListTest {
public static void main(String[] args) {
//LinkedList可以完成队列结构和栈结构
//栈
LinkedList<String> ll=new LinkedList<>();
//入栈
ll.addFirst("第一块积木");
ll.addFirst("第二块积木");
ll.addFirst("第三块积木");
ll.addFirst("第四块积木");
ll.addFirst("第五块积木");
System.out.println(ll);
//出栈
System.out.println(ll.removeFirst());
System.out.println(ll.removeFirst());
System.out.println(ll.removeFirst());
System.out.println(ll.removeFirst());
System.out.println(ll);
/* [第五块积木, 第四块积木, 第三块积木, 第二块积木, 第一块积木] 第五块积木 第四块积木 第三块积木 第二块积木 [第一块积木] */
//队列
LinkedList<String> ll1=new LinkedList<>();
//入队
ll1.addLast("1");
ll1.addLast("2");
ll1.addLast("3");
ll1.addLast("4");
ll1.addLast("5");
System.out.println(ll1);
//出队
System.out.println(ll1.removeLast());
System.out.println(ll1.removeLast());
System.out.println(ll1.removeLast());
System.out.println(ll1.removeLast());
System.out.println(ll1);
/* [1, 2, 3, 4, 5] 5 4 3 2 [1] */
}
}
1.HashSet类
package com.set.hashSet;
import java.util.HashSet;
import java.util.Set;
public class Test1 {
public static void main(String[] args) {
Set<String> sets=new HashSet<>();
sets.add("小马哥");
sets.add("小飞侠");
sets.add("马奎斯");
sets.add("罗西");
System.out.println(sets); //[马奎斯, 小马哥, 罗西, 小飞侠]
}
}
案例:
package com.set.hashSet;
public class Student {
private String name;
private int age;
private char sex;
public Student() {
}
public Student(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
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;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
if (age != student.age) return false;
if (sex != student.sex) return false;
return name.equals(student.name);
}
@Override
public int hashCode() {
int result = name.hashCode();
result = 31 * result + age;
result = 31 * result + (int) sex;
return result;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sex=" + sex +
'}';
}
}
package com.set.hashSet;
import java.util.HashSet;
import java.util.Set;
public class StudentTest {
public static void main(String[] args) {
Set<Student> sets=new HashSet<>();
sets.add(new Student("小马哥",34,'男'));
sets.add(new Student("小马哥",34,'男'));
sets.add(new Student("小飞侠",24,'女'));
System.out.println(sets); //[Student{name='小飞侠', age=24, sex=女}, Student{name='小马哥', age=34, sex=男}]
}
}
注意:
2.TreeSet类
package com.set.TreeSet;
import java.util.Set;
import java.util.TreeSet;
public class Test1 {
public static void main(String[] args) {
Set<Integer> s1=new TreeSet<>(); //无序,不重复,可排序
s1.add(21);
s1.add(12);
s1.add(12);
s1.add(1);
s1.add(56);
s1.add(45);
System.out.println(s1); //[1, 12, 21, 45, 56]
Set<String> s2=new TreeSet<>(); 无序,不重复,可排序
s2.add("小马哥");
s2.add("A");
s2.add("Z");
s2.add("D");
s2.add("z");
s2.add("a");
System.out.println(s2); //[A, D, Z, a, z, 小马哥]
}
}
1.自然排序和比较器排序
案例:
package com.set.TreeSet;
public class Student implements Comparable<Student> {
private String name;
private int age;
private double score;
public Student(String name) {
this.name = name;
}
public Student(String name, int age, double score) {
this.name = name;
this.age = age;
this.score = score;
}
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;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
//第一种类定义比较规则
@Override
public int compareTo(Student o) {
//按照年龄排序
//return this.getAge()-o.getAge(); //去掉了年龄相同的元素
//[Student{name='小马哥', age=23, score=99.9}, Student{name='马奎斯', age=34, score=70.9}, Student{name='罗西', age=44, score=85.5}]
return this.getAge()-o.getAge()>=0?1:-1; //保留了年龄相同的元素
//[Student{name='小马哥', age=23, score=99.9}, Student{name='小飞侠', age=23, score=89.5}, Student{name='马奎斯', age=34, score=70.9}, Student{name='罗西', age=44, score=85.5}]
}
}
package com.set.TreeSet;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
public class StudentTest {
public static void main(String[] args) {
//集合自带比较器对象进行规则制定
Set<Student> s=new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
// return (int) (o1.getScore()-o2.getScore()); //升序
return (int) (o2.getScore()-o1.getScore()); //降序
//[Student{name='小马哥', age=23, score=99.9}, Student{name='小飞侠', age=23, score=89.5}, Student{name='罗西', age=44, score=85.5}, Student{name='马奎斯', age=34, score=70.9}]
}
});
s.add(new Student("小马哥",23,99.9));
s.add(new Student("小飞侠",23,89.5));
s.add(new Student("马奎斯",34,70.9));
s.add(new Student("罗西",44,85.5));
System.out.println(s);
}
}
注意:
package com.params;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
//不传参数
//sum();
//可以传一个参数
sum(12);
//可以传多个参数
sum(23,34,45);
//可以传一个数组
//sum(new int[]{12,23,34,45});
}
public static void sum(int age,int ... num){
System.out.println("元素个数:"+num.length);
System.out.println("元素内容:"+ Arrays.toString(num));
}
}
/* 元素个数:0 元素内容:[] 元素个数:1 元素内容:[12] 元素个数:3 元素内容:[23, 34, 45] 元素个数:4 元素内容:[12, 23, 34, 45] */
案例:
package com.collection.collections;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Test {
public static void main(String[] args) {
List<String> list=new ArrayList<>();
/*list.add("小马哥"); list.add("小飞侠"); list.add("马奎斯"); list.add("罗西");*/
//批量添加元素
Collections.addAll(list,"小马哥","小飞侠","马奎斯","罗西"); //[小马哥, 小飞侠, 马奎斯, 罗西]
System.out.println(list);
//打乱集合顺序
Collections.shuffle(list);
System.out.println(list); //[马奎斯, 小飞侠, 罗西, 小马哥]
//将集合中元素按默认规则排序
List<Integer> l=new ArrayList<>();
Collections.addAll(l,12,34,23,78,99,35);
Collections.sort(l);
System.out.println(l); //[12, 23, 34, 35, 78, 99]
//将集合中元素按指定规则排序
}
}
1.Map集合概述
案例:
package com.map;
import java.util.HashMap;
import java.util.Map;
public class Test {
public static void main(String[] args) {
Map<String,Integer> m=new HashMap<>();
m.put("小马哥",33);
m.put("小飞侠",44);
m.put("马奎斯",33);
m.put("罗西",45);
m.put(null,null);
System.out.println(m); //{null=null, 马奎斯=33, 小马哥=33, 罗西=45, 小飞侠=44}
}
}
2.Map集合API
案例:
package com.map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test1 {
public static void main(String[] args) {
//创建Map集合
Map<String,Integer> m=new HashMap<>();
//添加元素
m.put("小马哥",33);
m.put("小飞侠",44);
m.put("马奎斯",33);
m.put("罗西",45);
//清空集合
//m.clear();
//System.out.println(m); //{}
//判断集合是否为空
System.out.println(m.isEmpty()); //false
//根据键获取对应的值
Integer i = m.get("小马哥");
System.out.println(i); //33
//根据键删除整个元素
System.out.println(m.remove("小马哥")); //33
System.out.println(m); //{马奎斯=33, 罗西=45, 小飞侠=44}
//判断是否包含某个键
System.out.println(m.containsKey("罗西")); //true
System.out.println(m.containsKey("小马哥")); //false
//判断是否包含某个值
System.out.println(m.containsValue(45)); //true
//获取全部键的集合
Set<String> keySet = m.keySet();
System.out.println(keySet); //[马奎斯, 罗西, 小飞侠]
//获取全部值的集合
Collection<Integer> values = m.values();
System.out.println(values); //[33, 45, 44]
//集合的大小
System.out.println(m.size()); //3
//合并其他Map集合
Map<String,Integer> m1=new HashMap<>();
m1.put("a",1);
m1.put("b",2);
Map<String,Integer> m2=new HashMap<>();
m1.put("c",3);
m1.put("d",4);
m1.putAll(m2); //把m2中的元素合并到m1中
System.out.println(m1); //{a=1, b=2, c=3, d=4}
}
}
3.Map集合遍历方式
1.键找值
案例:
package com.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test2 {
public static void main(String[] args) {
Map<String,Integer> m=new HashMap<>();
//添加元素
m.put("小马哥",33);
m.put("小飞侠",44);
m.put("马奎斯",33);
m.put("罗西",45);
//键找值
//先获取所有的键
Set<String> keys = m.keySet();
for (String key : keys) {
Integer values = m.get(key);
System.out.println(key+"="+values);
}
}
}
/* 马奎斯=33 小马哥=33 罗西=45 小飞侠=44 */
2.键值对
案例:
package com.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test3 {
public static void main(String[] args) {
Map<String,Integer> m=new HashMap<>();
//添加元素
m.put("小马哥",33);
m.put("小飞侠",44);
m.put("马奎斯",33);
m.put("罗西",45);
//把Map集合转换为set集合
Set<Map.Entry<String, Integer>> entries = m.entrySet();
//for遍历
for (Map.Entry<String, Integer> entry : entries) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"="+value);
}
}
}
/* 马奎斯=33 小马哥=33 罗西=45 小飞侠=44 */
注意:
本文为互联网自动采集或经作者授权后发布,本文观点不代表立场,若侵权下架请联系我们删帖处理!文章出自:https://blog.csdn.net/qq_43514330/article/details/125147390