JAVA SE学习day_12:集合的排序、队列、栈结构

最新推荐文章于 2024-07-08 14:41:41 发布

litter_m

最新推荐文章于 2024-07-08 14:41:41 发布

阅读量399

点赞数

文章标签：队列

本文链接：https://blog.csdn.net/litter_m/article/details/106151497

版权

一、集合的排序

1.1 集合的排序

集合的工具类java.util.Collections提供了一个静态方法sort，可以对List集合

进行自然排序，即：从小到大
除了自然排序之外还有反转、乱序方法

List<Integer>list = new ArrayList<>();
		
		Random random = new Random();
		for(int i =0;i<10;i++){
			list.add(random.nextInt(100));
		}
		System.out.println(list);
		//对集合进行排序，使其中的元素从小到大排列
		Collections.sort(list);
		System.out.println(list);
		//反转集合，如果是排序后的集合，则变为从大到小
		Collections.reverse(list);
		System.out.println(list);
		//乱序操作,打乱集合
		Collections.shuffle(list);
		System.out.println(list);

1.2 排序自定义元素的集合

sort方法要求集合必须实现Comparable，否则编译不通过。
当我们调用某一个API时，该API要求我名为其修改其他额外的代码时，这样的操作称为侵入性。
修改的代码越多，侵入性越强。侵入性不利于系统框架的健康，不利于程序的维护，应当尽量避免。
此时可以应对一个lambda重构一个匿名内部类

		List<Point>list = new ArrayList<>();
		list.add(new Point(1,2));
		list.add(new Point(9,5));
		list.add(new Point(4,6));
		list.add(new Point(8,3));
		System.out.println(list);
		/*
		 * 该sort方法要求集合必须实现Comparable，否则编译不通过
		 * 当我们调用某一个API时，该API要求我名为其修改其他额外的代码时，
		 * 这样的操作称为侵入性。修改的代码越多，侵入性越强。侵入性不利于
		 * 系统框架的健康，不利于程序的维护，应当尽量避免。
		 */
		 //		Collections.sort(list,new Comparator<Point>(){
//			public int compare(Point o1,Point o2){
//				int len1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
//				int len2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
//				return len1-len2;
//			}
//		});
//		Collections.sort(list,(o1,o2)->{
//				int len1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
//				int len2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
//				return len1-len2;
//		});
		Collections.sort(list,(o1,o2)->
			o1.getX()*o1.getX()+o1.getY()*o1.getY()-
			o2.getX()*o2.getX()-o2.getY()*o2.getY()
			);
		System.out.println(list);

1.3 排序字符串

String本身实现了Comparable接口，比较规这为按照字符的Unicode编码的大小对比，先看首字符，如果一样再看第二个字符。对于中文而言，几乎没有规律可言

		List<String>list = new ArrayList<>();
		list.add("jack");
		list.add("rose");
		list.add("tom");
		list.add("woold");
		list.add("jomes");
		System.out.println(list);
		/*
		 * String本身实现了Comparable接口，比较规这为按照字符的Unicode编码的
		 * 大小对比，先看首字符，如果一样再看第二个字符。
		 * 对于中文而言，几乎没有规律可言
		 */
//		Collections.sort(list);
		/*
		 * 自定义一个比较器，比较规则为按照字符多少排序，字少的在前，字多的在后
		 */
		Collections.sort(list,(l1,l2)->
		l1.length()-l2.length()
				);
		System.out.println(list);

二、队列

2.1 单端队列

队列是经典的数据结构，可以保存一组元素，但是存取元素必须遵循先进先出原则
java.util.Queue接口，队列接口，继承自Collection。
常用实现类：java.util.LinkedList

2.2 双端队列

java.util.Deque 接口双端队列。Deque接口继承自Queue接口。双端队列的
特点是队列的两端都可以进行入队操作。
实现类：java.util.LinkedList

三、栈结构

栈结构，栈是数据经典的结构之一，可以保存一组元素，但是存取元素必须遵循先进后出原则

使用栈一般是为了实现：后退、前进这样的功能

		Deque<String> stack = new LinkedList<>();
		stack.push("one");
		stack.push("two");
		stack.push("three");
		stack.push("four");
		stack.push("five");
		System.out.println(stack);
		
		String str = stack.pop();
		System.out.println(str);
		System.out.println(stack);

练习

		/*5*/
		List<Integer>l5 = new ArrayList<>();
		Random r5 = new Random();
		for(int i=0;i<10;i++){
			l5.add(r5.nextInt(100));
		}
		System.out.println(l5);
		Collections.sort(l5);
		System.out.println(l5);
		Collections.reverse(l5);
		System.out.println(l5);
		Collections.shuffle(l5);
		System.out.println(l5);
		/*4*/
		List<Integer>l4 = new ArrayList<>();
		Random r4 = new Random();
		for(int i=0;i<10;i++){
			l4.add(r4.nextInt(100));
		}
		System.out.println(l4);
		Collections.sort(l4);
		System.out.println(l4);
		Collections.reverse(l4);
		System.out.println(l4);
		Collections.shuffle(l4);
		System.out.println(l4);
		/*3*/
		List<Integer>l3 = new ArrayList<>();
		Random r3 = new Random();
		for(int i=0;i<10;i++){
			l3.add(r3.nextInt(100));
		}
		System.out.println(l3);
		Collections.sort(l3);
		System.out.println(l3);
		Collections.reverse(l3);
		System.out.println(l3);
		Collections.shuffle(l3);
		System.out.println(l3);
		/*2*/
		List<Integer>l2 = new ArrayList<>();
		Random r2 = new Random();
		for(int i=0;i<10;i++){
			l2.add(r2.nextInt(100));
		}
		System.out.println(l2);
		Collections.sort(l2);
		System.out.println(l2);
		Collections.reverse(l2);
		System.out.println(l2);
		Collections.shuffle(l2);
		System.out.println(l2);
		/*1*/
		List<Integer>l1 = new ArrayList<>();
		Random r1 = new Random();
		for(int i=0;i<10;i++){
			l1.add(r1.nextInt(100));
		}
		System.out.println(l1);
		Collections.sort(l1);
		System.out.println(l1);
		Collections.reverse(l1);
		System.out.println(l1);
		Collections.shuffle(l1);
		System.out.println(l1);

		/*5*/
		List<Point>l5 = new ArrayList<>();
		l5.add(new Point(1,2));
		l5.add(new Point(9,5));
		l5.add(new Point(4,6));
		l5.add(new Point(8,3));
		System.out.println(l5);
		Collections.sort(l5,(o1,o2)->
		o1.getX()*o1.getX()+o1.getY()*o1.getY()-
		o2.getX()*o2.getX()-o2.getY()*o2.getY()
		);
		System.out.println(l5);
		/*4*/
		List<Point>l4 = new ArrayList<>();
		l4.add(new Point(1,2));
		l4.add(new Point(3,7));
		l4.add(new Point(5,23));
		l4.add(new Point(6,2));
		l4.add(new Point(2,3));
		System.out.println(l4);
		Collections.sort(l4,(o1,o2)->
		o1.getX()*o1.getX()+o1.getY()*o1.getY()-
		o2.getX()*o2.getX()-o2.getY()*o2.getY()
				);
		System.out.println(l4);
		/*3*/
		List<Point>l3 = new ArrayList<>();
		l3.add(new Point(2,4));
		l3.add(new Point(4,7));
		l3.add(new Point(6,9));
		l3.add(new Point(2,6));
		System.out.println(l3);
		Collections.sort((l3),(o1,o2)->
		o1.getX()*o1.getX()+o1.getY()*o1.getY()-
		o2.getX()*o2.getX()-o2.getY()*o2.getY()
		);
		System.out.println(l3);
		/*2*/
		List<Point>l2 = new ArrayList<>();
		l2.add(new Point(1,3));
		l2.add(new Point(5,33));
		l2.add(new Point(55,5));
		l2.add(new Point(1,7));
		System.out.println(l2);
		Collections.sort(l2,(o1,o2)->
		o1.getX()*o1.getX()+o1.getY()*o1.getY()-
		o2.getX()*o2.getX()-o2.getY()*o2.getY()	
				);
		System.out.println(l2);
		/*1*/
		List<Point>l1 = new ArrayList<>();
		l1.add(new Point(1,3));
		l1.add(new Point(5,13));
		l1.add(new Point(15,6));
		l1.add(new Point(8,7));
		System.out.println(l1);
		Collections.sort(l1,(o1,o2)->
		o1.getX()*o1.getX()+o1.getY()*o1.getY()-
		o2.getX()*o2.getX()-o2.getY()*o2.getY()	
				);
		System.out.println(l1);

		/*5*/
		Queue<String> q5 = new LinkedList<>();
		q5.offer("1");
		q5.offer("2");
		System.out.println(q5);
		String s5 = q5.poll();
		System.out.println(s5);
		System.out.println(q5);
		s5 = q5.peek();
		System.out.println(s5);
		System.out.println(q5);
		/*4*/
		Queue<String>q4 = new LinkedList<>();
		q4.offer("1");
		q4.offer("#");
		System.out.println(q4);
		String s4 = q4.poll();
		System.out.println(s4);
		System.out.println(q4);
		s4 = q4.peek();
		System.out.println(s4);
		System.out.println(q4);
		/*3*/
		Queue<String>q3 = new LinkedList<>();
		q3.offer("2");
		q3.offer("@");
		System.out.println(q3);
		String s3 = q3.poll();
		System.out.println(s3);
		System.out.println(q3);
		s3 = q3.peek();
		System.out.println(s3);
		System.out.println(q3);
		/*2*/
		Queue<String>q2 = new LinkedList<>();
		q2.offer("1");
		q2.offer("@");
		System.out.println(q2);
		String s2 = q2.poll();
		System.out.println(s2);
		System.out.println(q2);
		s2 = q2.peek();
		System.out.println(s2);
		System.out.println(q2);
		/*1*/
		Queue<String>q1 = new LinkedList<>();
		q1.offer("1");
		q1.offer("@");
		System.out.println(q1);
		String s1 = q1.poll();
		System.out.println(s1);
		System.out.println(q1);
		s1 = q1.peek();
		System.out.println(s1);
		System.out.println(q1);

		/*5*/
		Deque<String> d5 = new LinkedList<>();
		d5.offer("one");
		System.out.println(d5);
		d5.offerFirst("four");
		System.out.println(d5);
		d5.offerLast("five");
		System.out.println(d5);
		String s5 = d5.poll();
		System.out.println(s5);
		System.out.println(d5);
		/*4*/
		Deque<String>d4 = new LinkedList<>();
		d4.offer("1");
		System.out.println(d4);
		d4.offerFirst("2");
		System.out.println(d4);
		d4.offerLast("3");
		System.out.println(d4);
		String s4 = d4.poll();
		System.out.println(s4);
		System.out.println(d4);
		/*3*/
		Deque<String>d3 = new LinkedList<>();
		d3.offer("1");
		System.out.println(d3);
		d3.offerFirst("#");
		System.out.println(d3);
		d3.offerLast("$");
		System.out.println();
		String s3 = d3.poll();
		System.out.println(s3);
		System.out.println(d3);
		/*2*/
		Deque<String>d2 = new LinkedList<>();
		d2.offer("@");
		System.out.println(d2);
		d2.offerFirst("W");
		System.out.println(d2);
		d2.offerLast("1");
		System.out.println(d2);
		String s2 = d2.poll();
		System.out.println(s2);
		System.out.println(d2);
		/*1*/
		Deque<String>d1 = new LinkedList<>();
		d1.offer("@");
		System.out.println(d1);
		d1.offerFirst("W");
		System.out.println(d1);
		d1.offerLast("1");
		System.out.println(d1);
		String s1 = d1.poll();
		System.out.println(s1);
		System.out.println(d1);

		
		/*5*/
		Deque<String>s5 = new LinkedList<>();
		s5.push("1");
		s5.push("@");
		System.out.println(s5);
		String str5 = s5.pop();
		System.out.println(str5);
		System.out.println(s5);
		/*4*/
		Deque<String>s4 = new LinkedList<>();
		s4.push("Q");
		s4.push("A");
		System.out.println(s4);
		String str4 = s4.pop();
		System.out.println(str4);
		System.out.println(s4);
		/*3*/
		Deque<String>s3 = new LinkedList<>();
		s3.push("1");
		System.out.println(s3);
		String str3 = s3.pop();
		System.out.println(str3);
		System.out.println(s3);
		/*2*/
		Deque<String>s2 = new LinkedList<>();
		s3.push("2");
		System.out.println(s2);
		String str2 = s2.pop();
		System.out.println(str2);
		System.out.println(s2);
		/*1*/
		Deque<String>s1 = new LinkedList<>();
		s3.push("55");
		System.out.println(s1);
		String str1 = s1.pop();
		System.out.println(str1);
		System.out.println(s1);