java第十课集合框架

最新推荐文章于 2022-03-31 10:56:08 发布

birdlun

最新推荐文章于 2022-03-31 10:56:08 发布

阅读量398

点赞数

分类专栏： 01 java

本文链接：https://blog.csdn.net/Birdmotianlun/article/details/89810614

版权

01 java 同时被 2 个专栏收录

82 篇文章 5 订阅

订阅专栏

大数据工程师学习路线

28 篇文章 0 订阅

订阅专栏

引入

数组

1.可以用来存储一组数据类型相同的数据

2.（固定长度）不便于程序的扩展。

3.对于数组中的元素进行  修改，删除，插入  整个数组中的结构发生变化，操作逻辑极其复杂

集合

1.根据元素的个数  长度自动增长，

2.底层定义了修改，插入，删除的功能方法，效率更高。

集合框架

框架就是一个类库的集合。集合框架就是用来表示和操作集合的统一架构，它包含了实现集合的类接口与类
集合类存放在java.util包中，今后进行程序编程时将大量使用集合类和相关接口

Iterator<T> iterator()

返回一个在一组 T 类型的元素上进行迭代的迭代器。返回：一个迭代器。

Collection	接口集合父类	无序可以重复
List		有序可以重复
Set		无序不可重复
ArrayList	数组结构	有序可以重复
LinkedList	链表结构	有序可以重复
TreeMap/HashMap	键值对方式保存数据

常用：ArrayList/HashSet

Collection接口

Collection表示一组对象，这些对象也称为 collection 的元素

常用方法

int size()返回collection中元素数
Object[] toArray() 返回所有元素数组
boolean add()
void clear()
remove()
boolean equals() 比较是否相等
boolean isEmpty()
Iterator<E> iterator()

ArrayList

数组结构

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 数组原则：用来存储一组数据类型相同的数据
		// 泛型：约束集合的数据类型
		ArrayList<String> list1 = new ArrayList<String>();
		// 往集合中添加数据的方法 add();
		// （有序：按照添加的顺序排序）
		// (可重复:同一个值可以保存多个)
		list1.add("a");
		list1.add("b");
		list1.add("c");
		list1.add("d");
		list1.add("e");
		System.out.println("显示原始数据："+list1);
		// 1.往集合中插入数据 将 frank 插入到第一位(0)
		list1.add(0, "frank");
		// 2.删除集合中的数据 根据下标或者值
		list1.remove(3);
		// 3.修改指定 位置的值
		list1.set(0, "zhangsan");
		System.out.println(list1);

		
		//遍历数组  （数组的长度  。length）
				//遍历集合 （集合的长度  size() ）
		for(int i=0;i<list1.size();i++){
			//从集合中拿数据  根据下表 list1.get(0);
			System.out.println(list1.get(i));
		}

列：ArrayList容器1）创建Student类，包含String类型的name，int类型的age，double类型的score，并重写getter、setter等方法。2）创建5个Student对象，保存到ArrayList容器中。3）通过迭代器和增强for循环两种方式遍历该集合。

public class Student {
	private String name;
	private int age;
	private double score;
	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;
	}
	
	public  void  show(){
		System.out.println(name+"\t"+age+"\t"+score);
	}
	
}

	public static void main(String[] args) {
		ArrayList<Student> list=new ArrayList<Student>();
		list.add(new Student("zs1",18,89));
		list.add(new Student("zs2",28,59));
		list.add(new Student("zs3",16,67));
		list.add(new Student("zs4",23,94));
		list.add(new Student("zs5",21,56));
		list.add(new Student("zs6",24,89));
		//简单for
		System.out.println("姓名\t年龄\t分数");
		for(int i=0;i<list.size();i++){
			list.get(i).show();
		}
		System.out.println("*************");
		//增强for循环
		for(Student stu : list){
			stu.show();
		}
		System.out.println("*****************");
		//迭代器
		Iterator<Student> it=list.iterator();
		while(it.hasNext()){
			Student stu=it.next();
			stu.show();
		}

列：在Arraylist中存放以下数据：“张三”、“李四”、“王五”、“张三”、“aaa”、“aaa”、“bbb” 要求：去除ArrayList中的重复元素。

List<String> list=new ArrayList<String>();
		list.add("张三");
		list.add("李四");
		list.add("王五");
		list.add("张三");
		list.add("aaa");
		list.add("bbb");
		list.add("aaa");
		list.add("aaa");
		//将list集合转换成  set集合
		HashSet<String> set=new HashSet<String>(list);
		System.out.println(set);

LinkedList

链表结构，双向链表结构

public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*
		 * 双向链表数据结构，
		 * 每一个Node对象，Node对象中封装的是你要添加的元素
		 * 链表数据结构，插入删除效率高
		 * 数据结构，查询效率高，可以通过下表直接找到该元素
		 * 但是删除和插入效率低，因为要做移位操作
		 */
		LinkedList<String> list=new LinkedList<String>();
		//ArrayList能用的方法基本都能用
		list.add("Jack");
		list.add("Jack");
		list.add("Jack");
		list.add("rouse");
		list.add("marry");
		list.add("frank");
		
		System.out.println("显示原始数据："+list);
		//插入/删除/修改
		list.add(0,"姓名");
		System.out.println("显示插入后数据："+list);
		list.remove(1);
		System.out.println("显示移除后数据："+list);
		list.set(0, "杰克");
		System.out.println("显示修改后数据："+list);
		
		list.addFirst("oook");
		list.addLast("koooo");
		
		for(int i=0;i<list.size();i++){
			System.out.println(list.get(i));
		}
	}

HastSet

无需列表，数据不可以重复

public static void main(String[] args) {
		// TODO Auto-generated method stub
		HashSet<String> hash = new HashSet<String>();
		//无序(无下标)，不可重复
		hash.add("zhangsan");
		hash.add("lisi");
		hash.add("lisi");
		hash.add("lisi");
		hash.add("王五");
		hash.add("赵六");
		System.out.println("原始数据"+hash);
		
		//返回集合的长度
		System.out.println("集合长度："+hash.size());
		/*
		 * 使用迭代器遍历集合
		 * iter.hasNext()：迭代器中下一个数据
		 */
		//1.获取对应集合的迭代器对象
		Iterator<String> iter=hash.iterator();
		//it.hasNext()：如果迭代器里面还有数据返回true 否则返回false
		while (iter.hasNext()) {
			String name=iter.next();
			System.out.println(name);
		}
	}

TreeSet

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TreeSet<String> set = new TreeSet<String>();
		set.add("张三");
		set.add("张三");
		set.add("张三");
		set.add("张三");
		set.add("李四");
		set.add("charles");
		set.add("王五");
		set.add("赵六");
		System.out.println("显示原始数据" + set);
        //显示结合的长度
		System.out.println("集合长度"+set.size());
		Iterator<String> iter=set.iterator();
		while (iter.hasNext()) {
			String string = (String) iter.next();
			System.out.println(string);
			
		}
	}

HashMap

map.keySet() 拿到键的集合（set集合）
map.get(i) 获取键值
map.containsKey(i)判断键是否存在

键：不可重复

public class HashMapTest {

	static HashMap<String, String> map;

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		map = new HashMap<String, String>();
		map.put("张三", "yiban");
		map.put("李四", "一班");
		map.put("王五", "一班");
		map.put("Jack", "二班");
		map.put("王", "二班");
		System.out.println("显示原始数据" + map);
        //修改数据
		map.put("王五", "2班");
		System.out.println("修改后的数据" + map);
        //删除数据
		map.remove("Jack");
		System.out.println("删除后的数据" + map);
        //4.如何根据键获取值  键不存在  返回null
		System.out.println(map.get("李四"));
		/*
		 * 遍历数据的四种方法
		 */
		System.out.println("iterator方法1");
		fangfa1();
		System.out.println("方法2");
		fangfa2();
		System.out.println("方法3");
		fangfa3();
		System.out.println("方法4");
		fangfa4();

	}

	private static void fangfa4() {
		// TODO Auto-generated method stub
		Set<Entry<String, String>> set = map.entrySet();
		Iterator<Entry<String, String>> its = set.iterator();
		while (its.hasNext()) {
			//
			Entry<String, String> entry = its.next();
			System.out.print(entry.getKey() + "+++++");
			System.out.println(entry.getValue());
		}
	}

	private static void fangfa3() {
		for (String key : map.keySet()) {
			String value = map.get(key);
			System.out.println(key + "\t\t" + value);
		}

	}

	private static void fangfa2() {
		// TODO Auto-generated method stub
		// 将键和值 封装到 entry（key,value） 对象里面
		Set<Entry<String, String>> set = map.entrySet();
		for (Entry<String, String> entry : set) {
			System.out.println(entry.getKey() + "----" + entry.getValue());
		}
	}

	private static void fangfa1() {
		// TODO Auto-generated method stub
		// 1.map.keySet():得到键的set集合 2.遍历键的集合
		Iterator<String> it = map.keySet().iterator();
		while (it.hasNext()) {
			String key = (String) it.next();
			String value = map.get(key);
			System.out.println(key + "\t\t" + value);

		}
	}

}

列：“asdascveasrgdfsdf”获取该字符串中，每一个字母出现的次数。要求：打印结果是：a(2)b(1)...

        String str="aaabbccddeeeeee";
        //定义map集合
		HashMap<Character,Integer> map=new HashMap<Character,Integer>();
		//  china: charAt(indnex):根据指定的索引值 返回对应的字符值 
		for(int i=0;i<str.length();i++){
			if(map.containsKey(str.charAt(i))){
				map.put(str.charAt(i), map.get(str.charAt(i))+1);
			}else{
				map.put(str.charAt(i),1);
			}
		}
		String temp="";
		for(char c : map.keySet()){
			char key=c;
			int value=map.get(c);
			temp=temp+key+"("+value+"),";
		}
        //substring(0,temp.length()-1)去掉最后一个逗号
		System.out.print(temp.substring(0,temp.length()-1));

列：在HashMap中存放以下数据：“张三”、“李四”、“王五”、“张三”、“aaa”、“aaa”、“bbb” 要求：统计重复元素。

HashMap<String,Integer> map=new HashMap<String,Integer>();
		//1.将数组中的数据保存在集合中
		for(int i=0;i<strs.length;i++){
			//1.如果元素在集合中已经存在了  那么   次数加1即可
			//2.如果元素在集合中不存在   那么 次数默认赋值为1 
			//3.集合通过不存在的键  获取到的值为null
			//map.get(strs[i])==null
			if(map.containsKey(strs[i])){//键存在 返回true  否则返回false
				//存在
				String key=strs[i];
				int value=map.get(key)+1;//修改值即可  在原来的基础之上加1
				map.put(key,value);
			}else{
				//不存在(说明此元素在集合中是第一次出现的)
				map.put(strs[i],1);
			}
		}
		System.out.println(map);

列：随机产生50个30到35的整数，统计每个数字出现的次数（TreeMap实现），输出时按照数字的降序排列，并且统计出现次数最多的数字和它的次数。 PS：如果有两个数字出现的次数一样，则只需输出其中一个。

public class Test {
	static TreeMap<Integer, Integer> treeMap;

	public static void main(String[] args) {
		treeMap = new TreeMap<Integer, Integer>();
		Random random = new Random();
		for (int i = 0; i < 50; i++) {
			int key = random.nextInt(6) + 30;
			Integer value = treeMap.get(key);
			if (value == null) {
				treeMap.put(key, 1);
			} else {
				treeMap.put(key, value + 1);
			}
		}
		fangfa1();
		fangfa2();

	}

	private static void fangfa2() {
		System.out.println("方法2");
		// TODO Auto-generated method stub
		Set<Entry<Integer, Integer>> entrySet = treeMap.entrySet();
		int max = 0;
		Entry<Integer, Integer> entryMax = null;
		for (Entry<Integer, Integer> entry : entrySet) {
			if (entry.getValue() > max) {
				max = entry.getValue();
				entryMax = entry;
			}
			System.out.println(entry.getKey() + "\t\t" + entry.getValue());
		}
		System.out.println("出现次数最多的是" + entryMax.getKey() + ",出现了" + entryMax.getValue() + "次");
	}

	private static void fangfa1() {
		// TODO Auto-generated method stub
		// 迭代器
		Iterator<Integer> key = treeMap.keySet().iterator();
		System.err.println("产生数字" + "\t\t" + "出现次数");

		Integer keyNext = null;
		Integer value = null;
		int maxValue = 0;
		int maxKey = 0;
		while (key.hasNext()) {
			keyNext = key.next();
			value = treeMap.get(keyNext);

			System.out.println(keyNext + "\t\t" + value);
			if (value > maxValue) {
				maxValue = value;
				maxKey = keyNext;
			}
		}

		System.out.println("出现次数最多的是" + maxKey + ",出现了" + maxValue + "次");
	}
}

集合工具类

Collections--类集工具类，定义了若干用于类集和映射的算法，这些算法被定义为静态方法。

public static void sort(List<T> list) // 排序
public static int binarySearch(List<T> list, T key)//返回数据在集合中的索引位置
public static void reverse(List<?> list) //反转
public static void shuffle(List<?> list)//随机打乱顺序
public static void swap(List<?> list, int i, int j)//交换
public static void min(List<?> list)//求最小值
public static void max(List<?> list)//求最大值

	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(89);
		list.add(99);
		list.add(79);
		list.add(69);
		list.add(100);
		System.out.println("原始数据" + list);
		Collections.sort(list);
		System.out.println("排序数据" + list);

		// 2.集合中的数据反转
		Collections.reverse(list);
		System.out.println("反转之后:" + list);

		/*
		 * 3.binarySearch(list,value):返回指定数据在集合中的索引位置 注意:只有排完序之后的集合此方法才可用（必须是顺序）。
		 */
		System.out.println(Collections.binarySearch(list, 89));

		// 4.随即打乱集合中的数据顺序
		Collections.shuffle(list);
		System.out.println("随机打乱:" + list);

		// 5.最大值/最小值
		System.out.println("最大值:" + Collections.max(list));
		System.out.println("最小值:" + Collections.min(list));

		// 6.在集合中根据索引位置进行数据交换
		Collections.swap(list, 0, list.size() - 1);
		System.out.println("第一个元素和最后一个元素交换之后:" + list);
		
		System.out.println("--------------数组排序----------------------");
		arraySort();
	}
	//数组的升序  降序
	public static void arraySort(){
		int[] arr={1,10,9,6,20,78,13};
		//排序  顺序排序
		Arrays.sort(arr);
		/*for(int ele : arr){
			System.out.print(ele+",");
		}*/
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+",");
		}
		System.out.println("");
		System.out.println("倒序输出");
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[arr.length-i-1]+",");
		}
	}

比较器

Comparable(自比较)
Comparator(类比较)

Students类

public class Students implements Comparable<Students>{
	//封装属性
		private String stuName;
		private int score;
		private int age;
		public Students(String stuName, int score, int age) {
			this.stuName = stuName;
			this.score = score;
			this.age = age;
		}
		public Students() {
		}
		public String getStuName() {
			return stuName;
		}
		public void setStuName(String stuName) {
			this.stuName = stuName;
		}
		public int getScore() {
			return score;
		}
		public void setScore(int score) {
			this.score = score;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}	
		//方便测试 
		@Override
		public String toString(){
			return  stuName+"-"+score+"-"+age;
		}
		/*@Override
		public int compareTo(Student stu){
			//要求按照成绩顺序 从小到大
			//倒序就是 : stu.score-this.score
			return this.score-stu.score;
		}*/
		
		/*@Override
		public int compareTo(Student stu) {
			// str1.compareTo(str2)  等价于  str1-str2
			//如果 str1>str2   1   否则  返回 -1   相等 返回 0
			return this.stuName.compareTo(stu.stuName);
		}*/
		//按照成绩降序排序  如果成绩相同  按照姓名顺序排序
		@Override
		public int compareTo(Students stu) {
			if(this.score==stu.score){
				return this.stuName.compareTo(stu.stuName);
			}else{
				return stu.score-this.score;
			}
		}

public class StuCompareToAge implements Comparator<Students> {

	@Override
	public int compare(Students o1, Students o2) {
		// TODO Auto-generated method stub
		return o1.getAge()-o2.getAge();
	}

}

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<Students> list = new ArrayList<Students>();
		list.add(new Students("charles", 89, 18));
		list.add(new Students("jack", 68, 20));
		list.add(new Students("rouse", 89, 16));
		list.add(new Students("frank", 99, 22));
		list.add(new Students("pop", 56, 14));
		System.out.println(list);

       //使用类比较
		Collections.sort(list, new StuCompareToAge());
		System.out.println("类比较\n年龄排序" + list);

		Collections.sort(list);
		System.out.println("成绩排序"+list);
	}
}

birdlun

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java第十课集合框架

目录引入数组集合框架Collection接口ArrayListLinkedListHastSetTreeSetHashMap集合工具类比较器引入数组 1.可以用来存储一组数据类型相同的数据 2.（固定长度）不便于程序的扩展。 3.对于数组中的元素进行修改，删除，插入整个数组中的结构发生变化，操...
复制链接

扫一扫