JavaSE09

最新推荐文章于 2024-09-15 14:22:14 发布

原创最新推荐文章于 2024-09-15 14:22:14 发布 · 235 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

java 同时被 2 个专栏收录

32 篇文章

订阅专栏

JAVASE

14 篇文章

订阅专栏

本文介绍Java中如何使用Collections工具类对List集合进行排序，包括基本类型、自定义类型的排序方法，以及如何通过比较器自定义排序规则。此外，还介绍了如何在Java中将数组转换为集合，以及集合转换为数组的方法。

package day09;
/**
 * 排序集合
 * 排序集合可以使用集合的工具类
 * java.util.Collections
 * 
 * 其定义很多静态方法，用于操作集合，其中sort()方法是对
 * List集合进行自然排序（升序）
 */
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Collection_sort {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		for(int i=0;i<10;i++){
			list.add((int)(Math.random()*100));
		}
		System.out.println(list);
		//对集合List进行升序排序
		Collections.sort(list);
		
		
		/*
		int[] arr = {23,2,3,65,12};
		//升序排列
		Arrays.toString(arr);
		System.out.println(Arrays.toString(arr));
		*/
		
		
	}
}

package day09;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import day08.Point;
/**
 * 排序自定义类型元素的集合
 * @author 臻冉
 *
 */
public class Collections_sort02 {
	public static void main(String[] args) {
		List<Point> list = new ArrayList<Point>();
		list.add(new Point(2,3));
		list.add(new Point(5,9));
		list.add(new Point(1,6));
		list.add(new Point(2,5));
		list.add(new Point(6,4));
		System.out.println(list);
		Collections.sort(list);
		System.out.println("自定义排序"+list);
	}
}

package day09;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Collection_sort03 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("张翠花");
		list.add("李四");
		list.add("小李飞刀");
		Collections.sort(list);
		System.out.println("排序后的结果："+list);
		
		/*
		 * 推荐的排序方式
		 * 当遇到排序自定义类型元素，或者集合元素自身的比较规则不满足排序时
		 * 都建议使用下面的方式排列
		 * 该sort方法要求额外传入一个比较器规则比较集合元素并进行排序，因此
		 * 排序犯法不要求集合元素实现Comparable接口
		 */
		
		Collections.sort(list,new Comparator<String>() {
			//自定义排序根据字符串的长度排序
			public int compare(String o1, String o2) {
			
				return o1.length()-o2.length();//排序
			}
		} );
		System.out.println("自定义排序后的结果"+list);
	}
}

package day09;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 使用比较器来对Point02对象属性自定义进行排序
 * @author 臻冉
 *
 */
public class Collection_sort04 {
	public static void main(String[] args) {
		List<Point02> list = new ArrayList<Point02>();
		list.add(new Point02(1,2));
		list.add(new Point02(6,4));
		list.add(new Point02(1,1));
		list.add(new Point02(3,6));
		list.add(new Point02(5,6));
		System.out.println("原集合："+list);
		Collections.sort( list, new Comparator<Point02>() {
			public int compare(Point02 o1, Point02 o2) {
				int len=o1.getX()*o1.getX()+o1.getY()*o1.getY();
				int olen =o2.getX()*o2.getX()+o2.getY()*o2.getY();
				return len-olen;//排序
			}
		} );
		System.out.println("自定义排序后的结果"+list);
	}
}

package day09;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 数组转换为集合
 * 通过集合的工具类Arrays的静态方法alList可以将一个数组转换为List集合
 * @author 臻冉
 *
 */
public class ArrayToListDemo {
	public static void main(String[] args) {
		String[] array = new String[]{"one","two","three","four"};
		
		//数组转换为集合   但是对象还是同一个对象
		List<String> list = Arrays.asList(array);
		
		list.set(0, "1");
		System.out.println(list);
		//对集合元素的操作就是对原数组的操作
		System.out.println("源数组"+Arrays.toString(array));
		/*
		 * 由于添加数组会导致数组扩容，那就不能表示源数组
		 * 这样的操作在数组转换的集合中是不支持的
		 */
		//list.add("five";)//抛异常
		//list.remove("1");
		//System.out.println("源数组："+Arrays.toString(array));
		
		//集合复制
		List<String> list2 = new ArrayList<String>(list);
		list2.add("five");
		System.out.println("list2集合："+list2);
		
	}
}

package day09;

import java.util.ArrayList;
import java.util.List;

/**
 * 集合转换为数组
 * Collection提供了一个方法：toArray,可以将当前集合转换为数组
 * @author 臻冉
 *
 */
public class ListToArrayDemo {
	public static void main(String[] args) {
		
		List<String> list = new ArrayList<String>();
		list.add("one");
		list.add("two");
		list.add("three");
		list.add("four");
		//把集合和转换为数组
		String[] s = new String[0];
		String[] str = list.toArray(s);
		System.out.println(str.length);
		for(String st:str){
			System.out.println(st);
		}
		
	}
}

package day09;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * java.util.List线性表
 * List的特点:可重复并且有序，可以通过下表操作元素；
 * 常用实现类：
 * ArrayList：内部有数组实现，查询快，增删慢，
 * LinkedList:内部有链表实现，查询慢，增删快
 * 
 * 对于行不是极端苛刻的情况下，通常使用ArrayList
 * 含头不含尾
 * 
 * 截取指定范围的子集
 * 
 * @author 臻冉
 *
 */
public class List_get_set {
	public static void main(String[] args) {
		
		List<String> list = new ArrayList<String>();
		list.add("one");
		list.add("two");
		list.add("three");
		list.add("four");
		//System.out.println(list);
		
		/* * E get(int index)
		 * 获取指定位置对应的元素*/
		 
		String str = list.get(1);
		//System.out.println(str);
		
		//传统的for循环可以遍历List集合
		for(int i=0;i<list.size();i++){
			String s = list.get(i);//获取集合中的每一个元素的下标返回下标所对应的元素
			//System.out.println(s);
		}
		
		//增强for循环(新循环)遍历List集合
		for(String s:list){
			//System.out.println(s);
		}
		
		//用迭代器遍历List集合
		Iterator<String> it = list.iterator();
		while(it.hasNext()){
			String s = it.next();
			//System.out.println(s);
		}
		
		
		 /** E set(int index,E e)
		 * 将指定元素设置到指定位置，返回值为原来位置对应的元素，所以是替换元素操作
		 */
		//[one,2,three,four]
		String ss = list.set(1, "2");
		System.out.println(ss);
		
		
		/* *  E remove(int index)*/
		 
		String old = list.remove(1);
		System.out.println("删除的元素是："+old);
		
	}
}

package day09;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * List<E> subList(int fromIndex,int toIndex);
 * 截取指定范围的子集
 *  含头不含尾
 *  @author 臻冉
 *
 */
public class List_subList {
	public static void main(String[] args) {
		
		
		
		//随机生成10个整数并存储到List集合中
		/*
		 * 参与集合中的泛型类型必须是方参与面向对象的类型，也就是包装类型
		 * 因此在这里参与集合的int类型必须是它的包装类型Integer类型
		 */ 
		List<Integer> list = new ArrayList<Integer>();
		Random random = new Random();
		for(int i=0;i<10;i++){
		    int number = random.nextInt(101);
			list.add(number);
		}
		System.out.println(list);
		
		//截取集合中的下标为3的元素到下标为8的元素
		List<Integer> subList = list.subList(3, 8);
		System.out.println("截取后的集合子集:"+subList);
		
		//截取3-7元素，并将子集元素扩大10倍
		List<Integer> subList1 = list.subList(3, 8);
		for(int i=0;i<subList1.size();i++){
			int s = subList1.set(i, subList.get(i)*10);
			
		}
		System.out.println(subList1);
		//对子集元素操作，就是对原集合对应元素的操作
		System.out.println("原来的List集合："+list);
		
		
		 // 删除list元素第三个到第七个
		 
		//subList1.clear();
		list.subList(3, 8).clear();
		System.out.println(list);
		
		
	}
}

package day09;

import java.util.ArrayList;
import java.util.List;

/**
 * List集合套用List集合
 * @author 臻冉
 *
 */
public class list_jd {
	public static void main(String[] args) {
		//热门推荐
		List<String> list1=new ArrayList<String>();
		list1.add("iphone");
		list1.add("honor");
		list1.add("vivo");
		
		List<String> list2=new ArrayList<String>();
		list2.add("5G手机");
		list2.add("华为");
		list2.add("小米");
		
		List<String> list3=new ArrayList<String>();
		list3.add("营业厅");
		list3.add("宽带");
		
		List<List<String>> itemize = new ArrayList<List<String>>();
		itemize.add(list1);
		itemize.add(list2);
		itemize.add(list3);
		
		for(List<String> li:itemize){
			for(String l:li){
				System.out.println(l);
			}
		}
		
		/*
		//热门推荐
		List<String> list1 = new ArrayList<String>();
		list1.add("iPhone");
		list1.add("honor");
		list1.add("小米");
		
		//热门分类
		List<String> list2 = new ArrayList<String>();
		list2.add("5G手机");
		list2.add("游戏手机");
		list2.add("拍照手机");
		
		//运营商
		List<String> list3 = new ArrayList<String>();
		list3.add("营业厅");
		list3.add("手机壳");
		list3.add("宽带");
		
		//手机分类
		List<List<String>> itemize = new ArrayList<List<String>>();
		itemize.add(list1);
		itemize.add(list2);
		itemize.add(list3);
		
		//遍历手机分类中的每一个集合中的每一个元素
		for(List<String> li:itemize){
			for(String l:li){
				System.out.println(l);
			}
		}
		*/
	}
}

package day09;

public class Point02{
	private int x;
	private int y;
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
	
	public Point02(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + x;
		result = prime * result + y;
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Point02 other = (Point02) obj;
		if (x != other.x)
			return false;
		if (y != other.y)
			return false;
		return true;
	}
	@Override
	public String toString() {
		return "Point02 [x=" + x + ", y=" + y + "]";
	}
	
}