JavaAPI02
APIDay02????日期操作1.Date及常用API表示当前系统时间Date date=new Date()；package LittleRabbit.Time;import java.util.Date;public class DateDemo {public static void main(String[] args) {Date now = new Date();/*** Date重
·
APIDay02🐇
日期操作
1.Date及常用API
- 表示当前系统时间 Date date=new Date()；
package LittleRabbit.Time;
import java.util.Date;
public class DateDemo {
public static void main(String[] args) {
Date now = new Date();
/**
* Date重写了toString
* 显示日期的格式对非英语地区不十分友好
*/
System.out.println(now);
}
}
-
把时间转换成毫秒 long time=date.getTime()；（1970到这时间的毫秒数）
-
毫秒转换成默认格式时间 date.setTime(time)；
package LittleRabbit.Time;
import java.util.Date;
/**
* java.util.Date
* Date内部维护一个long值，该值表示自1970年元旦到该对象表示的时间点之间所经过的毫秒值
* 由于Date存在时区，千年虫问题，所以在jdk1.1发布时大部分操作时间的方法全部被标注为过时方法，
* 不再建议使用。
* 现在Date仅用于表示一个具体的时间点。
* 补充：
* 已经不能用了
*
*/
public class DateDemo {
public static void main(String[] args) {
Date now = new Date();
System.out.println(now);
/**
* Date重写了toString
* 显示日期的格式对非英语地区不十分友好
*/
long time = now.getTime();
time += 1000*60*60*24;
now.setTime(time);
System.out.println(now);
/**
* void setTime(long time)
* 将给定的long值设置到当前Date对象中
* 使其表示这个时间
*/
}
}
2.SimpleDateFormat
- 将Date按照当前SDF指定日期格式转换为String字符串
SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str=sdf.format(date);
代码：
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormat01 {
public static void main(String[] args) {
Date now = new Date();
System.out.println(now);
/**
* 2016-12-26 10:20:55
* yyyy-MM-dd HH:mm:ss
*/
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
/**
* Date->String
* String format(Date date)
* 将给定的Date按照指定的日期格式转换为字符串
*/
String str = sdf.format(new Date());
System.out.println(str);
}
}
- 将字符串按照指定日期格式解析为Date对象
//将字符串按照指定的日期格式解析为Date对象
public class SimpleDateFormat02 {
public static void main(String[] args) throws ParseException{
String str = "2000-07-17 20:07:17";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
/*
String--->Date
Date parse(String str)
将指定字符串按照指定的日期格式解析
为Date，使其表示日期
*/
// Date date = sdf.parse(str);
System.out.println(sdf.parse(str));
}
}
Calendar类
- java.util.Calendar
日历类，是一个抽象类，规定了操作时间的相关方法
常用实现类：阳历历法GergorianCalendar
Calendar有一个静态方法可以根据所在地区获取相应的实现类。
Calendar 类用于封装日历信息，通常使用该类对时间进行操作。默认创建出来的Calendar的实现类表示当前系统时间
Calendar calendar=Calendar.getInstance();
//Calendar -->Date
Date date=calendar.getTime();
// Date -->Calendar
calendar.setTime(date);
代码：
import java.util.Calendar;
import java.util.Date;
public class Calendar_getInstance {
public static void main(String[] args) {
/**
* static Calendar getInstance()
* 该静态方法会根据系统所在地区获取一个适用
* 的实现类，大部分是阳历类。
* 并且默认表示当前系统时间。
*/
Calendar calendar = Calendar.getInstance();
/**
* Calendar的实现类也重写了toString了
* 只是不能直观的看出日期
*/
// System.out.println(calendar);
/**
* Calendar-->Date
* Date getTime()
* 该方法可以返回一个Date类型实例，该实例
* 表示的日期就是当前Calendar所表示的日期
*/
Date date = calendar.getTime();
System.out.println(date);
/*
* Date -> Calenar
* void setTime(Date date)
* 该方法可是使当前Calendar表示给定的
* Date所表示的日期
*/
calendar.setTime(date);
}
}
- Calendar_get
Calendar提供了获取各个时间分量的值的方法
//获取年？ int year=calendar.get(Calendar.YEAR);
//获取月？月从0开始，即：0表示1月
int month=calendar.get(Calendar.MONTH)+1;
//获取日？
int day=calendar.get(Calendar.DAY_OF_MONTH);月中的天
int day1=calendar.get(Calendar.DAY_OF_YEAR);年中的天
int day2=calendar.get(Calendar.DAY_OF_WEEK)-1;周中的天
String[] date ={“日”,“一”,“二”,“三”,“四”,“五”,“六”};
System.out.println(“今天是周”+date[day2]);
//获取时分秒
int h=calendar.get(Calendar.HOUR_OF_DAY);
int m=calendar.get(Calendar.MINUTE);
int s=calendar.get(Calendar.SECOND);
//获取时分秒
int h=calendar.get(Calendar.HOUR_OF_DAY);
int m=calendar.get(Calendar.MINUTE);
int s=calendar.get(Calendar.SECOND);
代码示例：
public class Calendar_Get {
public static void main(String[] args) {
Calendar calendar = Calendar.getInstance();
//获取年？
int year = calendar.get(Calendar.YEAR);
//获取月？月从0开始，0表示1月。
int month = calendar.get(Calendar.MONTH)+1;
//获取日？
/**
* 和日相关的常量:
* DATE 月中的天 与DAY_OF_MONTH一致
* DAY_OF_MONTH 月中的天(几号)
* DAY_OF_WEEK 星期几
* DAY_OF_YEAR 年中的天
*/
int day = calendar.get(Calendar.DAY_OF_MONTH);//月中的天
int day1=calendar.get(Calendar.DAY_OF_YEAR);//年中的天
int day2=calendar.get(Calendar.DAY_OF_WEEK)-1;//周中的天
System.out.println("今天的日期为"+year+"-"+month+"-"+day);
//今天是周几？
String[] date ={"日","一","二","三","四","五","六"};
System.out.println("今天是周"+date[day2]);
//获取时分秒？
int h = calendar.get(Calendar.HOUR_OF_DAY);
int m = calendar.get(Calendar.MINUTE);
int s = calendar.get(Calendar.SECOND);
System.out.println("现在的时间是"+h+"-"+m+"-"+s);
//今天是今年的第多少天？
System.out.println("今天是今年的第"+day1+"天！");
/**
* 获取给定时间分量所允许的最大值
*/
int days = calendar.getActualMaximum(Calendar.DAY_OF_YEAR);
System.out.println("今年共："+days+"天");
days = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
System.out.println("当月共："+days+"天");
}
}
- Calendar_set
设置年 月 日 时 分 秒
calendar.set(Calendar.YEAR,2008);
calendar.set(Calendar.MONTH,Calendar.AUGUST);
calendar.set(Calendar.DAY_OF_MONTH,8);
calendar.set(Calendar.HOUR_OF_DAY,20);
calendar.set(Calendar.MINUTE,8); calendar.set(Calendar.SECOND,8);
//Calendar允许对指定时间分量设置给定的值
public class Calendar_Set {
public static void main(String[] args) {
Calendar calendar = Calendar.getInstance();
/*
* 2008-08-08 20:08:08
*
* void set(int filed,int value)
* 针对给定的时间分量设置指定的值
*/
//设置年
calendar.set(Calendar.YEAR,2000);
System.out.println(calendar.getTime());
calendar.set(Calendar.MONTH,Calendar.AUGUST);
calendar.set(Calendar.DAY_OF_MONTH,7);
calendar.set(Calendar.HOUR_OF_DAY,17);
calendar.set(Calendar.MINUTE,7);
calendar.set(Calendar.SECOND,7);
System.out.println(calendar.getTime());
//设置周几？
calendar.set(Calendar.DAY_OF_WEEK,2);
System.out.println(calendar.getTime());
//超范围后会进位
calendar.set(Calendar.DAY_OF_MONTH,32);
System.out.println(calendar.getTime());
}
}
add增加指定时间方法
calendar.add(Calendar.YEAR,3); //加3年
calendar.add(Calendar.MONTH,1); //加1月
代码：
/**
* Calendar提供了用于计算日期的方法:
* void add(int field,int value)
* 对指定时间分量加上给定的值，若给定的值是负数，则是减去。
* @author Rabbit
*/
public class Calendar_Add {
public static void main(String[] args) {
//加上三个月
Calendar cal = Calendar.getInstance();
cal.add(Calendar.MONTH,3);
System.out.println(cal.getTime());
cal.add(Calendar.DAY_OF_YEAR,25);
System.out.println(cal.getTime());
//设置为当周的周一
cal.set(Calendar.DAY_OF_WEEK,2);
System.out.println(cal.getTime());
}
}
生命计时
根据用户输入的生日，计算该用户到今天为止
一共活了多少天?
要求用户输入的生日格式如:1992-08-02
public class 生命计时 {
public static void main(String[] args) throws ParseException {
//scanner获取用户输入内容
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你出生日期：yyyy-MM-dd");
String birthStr = scanner.nextLine();
//将用户输入的生日转换为Date对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date birthDate = sdf.parse(birthStr);
// System.out.println(birthDate);
//今天的日期
Date now = new Date();
/**
* 今天的毫秒减去生日的毫秒差为：
* 经过的毫秒
*/
long time = now.getTime()-birthDate.getTime();
// System.out.println(time);
//将经过的时间转换为天
time /= 1000*60*60*24;
System.out.println("恭喜您，已经活了"+time+"天!请珍惜每一天!");
scanner.close();
}
}
集合框架
1.Collection
集合，用于存储一组元素，与数组很像。集合规定了很多便于操作集合元素的方法。
Collection有两个常用的子接口：
List：可重复集 ，有序集，可以根据下标操作元素 Arraylist
Set: 不可重复集 HashSet
集合中存储的都是引用类型的元素，那么引用类型变量实际上存储的是对象的“地址”，所以实际上集合只存储了元素对象在堆中的地址。而并不是将对象本身存入了集合中。
//集合存放的是元素的引用
public class CollectionDemo {
public static void main(String[] args) {
Collection c = new ArrayList();
Point p = new Point(1,2);
c.add(p);
System.out.println("p:"+p);//(1,2)
System.out.println("c:"+c);//[(1,2)]
p.setX(2);
System.out.println("p:"+p);//(2,2)
System.out.println("c:"+c);//[(2,2)]
}
}
重复与否指的是集合内部的元素，而元素是否重复取决于与元素间equals比较的结果。
Collection c = new ArrayList();
c.add(“a”); c.add(“b”);
System.out.println©; // [a,b] 添加集合元素
c.size() 表示集合个数
c.isEmpty()判断当前集合是否不含有任何元素
c.clear(); 清空集合
import java.util.ArrayList;
public class Collection_Methods {
public static void main(String[] args) {
ArrayList c = new ArrayList();
/**
* boolean add(E e)
* 向当前集合中添加给定元素，若添加成功
* 则返回true
*/
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
c.add("six");
System.out.println(c);
/**
* int size()
* 获取集合的元素个数
*/
System.out.println("个数size"+c.size());
/**
* boolean isEmpty()
* 判断当前集合是否不含有元素
*/
System.out.println("是否含有元素isEmpty:"+c.isEmpty());
/**
*void clear()
* 清空所有元素
*/
c.clear();
System.out.println("集合已经清空!");
System.out.println("个数size:"+c.size());
System.out.println("是否含有元素isEmpty:"+c.isEmpty());
}
}
c.contains§；判断集合c是否包含元素p
public class Collection_Contains {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add(new Point(1,2));
c.add(new Point(2,3));
c.add(new Point(3,4));
c.add(new Point(4,5));
System.out.println(c);
Point p = new Point(1, 2);
boolean contains = c.contains(p);
System.out.println("包含："+contains);
}
}
判断当前集合是否包含给定元素，判定标准是看给定元素与集合现有元素是否有equals比较为true的。
//操作集合元素相关方法
public class Collection_Remove {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add(new Point(1,2));
c.add(new Point(2,3));
c.add(new Point(3,4));
c.add(new Point(1,2));
System.out.println(c);
/*
* boolean remove(E e)
* 从集合中删除给定元素
* 将给定元素与集合现有元素顺序进行equals比较，
* 并删除第一个与之比较为true的元素若成功删除元素则返回true
*/
Point p = new Point(1,2);
c.remove(p);
System.out.println(c);
}
}
2.Iterator 迭代器，遍历集合
集合提供了通用的遍历元素方式：迭代器模式。
迭代器java.util.Iterator是一个接口。
不同的集合实现类都提供了一个可以遍历自身元素的迭代器实现类，我们无需记住每个迭代器实现类的名字， 只要当Iterator看待可以操作并遍历集合元素即可。
迭代器遍历集合元素遵循: 问，取，删 的步骤 。其中删除元素操作不是必要操作。
package LittleRabbit.Collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Iterator_Remove {
public static void main(String[] args) {
Collection col = new ArrayList();
col.add(1);
col.add("#");
col.add(2);
col.add("#");
col.add(3);
col.add("#");
col.add(4);
col.add("#");
col.add(5);
Iterator it = col.iterator();
while (it.hasNext()){
if ("#".equals(it.next())){
it.remove();
}
}
System.out.println(col);
/*
先创建集合，再添加元素。然后创建该集合的迭代器
循环判断迭代器能否取出下一个元素，if取到所有指定字符，remove
循环结束后输出集合
*/
}
}
3.增强for循环（遍历数组集合）
增强for循环， 也称为新循环，for each。JDK1.5之后推出的新特性。新循环不能替代传统循环的工作，新循环使用来遍历集合或数组的
注意：
新循环并非新的语法，JVM并不认可新循环而是编译器认可。
编译器在编译源程序时，会将新循环遍历集合改为使用迭代器遍历。
为此，新循环在遍历集合时，不能通过集合的方法修改元素数量。
//for each 遍历数组
public class NewFor_Array {
public static void main(String[] args) {
String[] array = {"one","two","three","four","five"};
for (int i = 0; i < array.length; i++) {
String str = array[i];
System.out.println(str);
}
for (String str : array){
System.out.println(str);
}
/*
Collection c = new ArrayList();
for (int i = 0; i < 100; i++) {
c.add(i);
}
c.iterator().next();
System.out.println(c);
*/
}
}
//使用新循环遍历集合
public class NewFor_Collection {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
for (Object o : c){
String str = (String)o;
System.out.println(str);
}
// Iterator it = c.iterator();
// while(it.hasNext()){
// Object o = it.next();
// }
}
}
public class NewFor_print {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
for (Object o : c){
System.out.println(o);
}
}
}
4.泛型机制
什么是泛型？
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用调用时传入具体的类型（类型实参）。
泛型的本质就是参数化类型，也就是所操作的数据类型被指定为一个参数
- 编译器检查类型，类型安全
减少了数据类型转换
泛型在集合中被用来规定集合元素类型，迭代器的泛型与其遍历的集合泛型一致即可
/**
* 泛型在集合中的应用
* 集合在泛型中是用来规定集合中的元素类型
* @author rabbit
*/
public class Collection_Fan {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
for (String str : c){
System.out.println(str);
}
System.out.println();
/*
* 迭代器也支持泛型，而泛型的实际类型与
* 其遍历的集合的泛型类型一致即可
*/
Iterator<String> it = c.iterator();
while (it.hasNext()){
String str = it.next();
System.out.println(str);
}
}
}
package LittleRabbit.FanXing;
/**
* 什么是泛型？
* 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。
* 那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，
* 此时类型也定义成参数形式（可以称之为类型形参），然后在使用调用时传入具体的类型（类型实参）。
*/
public class Mian {
public static void main(String[] args) {
//泛型类在创建对象的时候,来指定操作的具体数据
Box<String> strbox = new Box<>("rabbit");
String str = strbox.getData();
System.out.println("String:"+str);
Box<Integer> intbox = new Box<>(123);
int i = intbox.getData();
System.out.println("Integer:"+i);
//泛型类在创建对象的时候没有指定类型，将按照Object类型操作
Box objectBox1 = new Box<>(123);
Box objectBox2 = new Box<>("wuwuwu");
System.out.println(objectBox1.getData());
System.out.println(objectBox2.getData());
//泛型不支持基本数据类型 int不能被类型擦除为Object,Integer可以
// Box <int> box = new Box<int>();
System.out.println("-----------------------------------");
//同一泛型类，根据不同的数据类型创建的对象，本质上都是同一类型(类类型)
System.out.println(strbox.getClass());
System.out.println(intbox.getClass());
System.out.println(strbox.getClass()==intbox.getClass());
}
}
/**
* 泛型类的定义
* @param <T>泛型标识--类型传参
* T创建对象的时候里指定具体的数据类型
*/
class Box<T>{
//T,是由外部实用类的时候来指定
private T data;
public Box(){}
public Box(T data){
this.data=data;
}
public T getData(){
return data;
}
public void setData(T data){
this.data=data;
}
@Override
public String toString() {
return "Box{" + "data=" + data + '}';
}
}
抽奖小游戏
package LittleRabbit.FanXing;
import java.util.ArrayList;
import java.util.Random;
public class Point<T>{
Random random = new Random();
//奖品
private T product;
//奖池
ArrayList<T> list = new ArrayList<>();
//添加奖品
public void add(T t){
list.add(t);
}
//抽奖
public T getProduct(){
product = list.get(random.nextInt(list.size()));
return product;
}
}
package LittleRabbit.FanXing;
import java.util.Scanner;
public class TestPoint {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请问您要抽'兔子'还是要抽'现金'(最高1w哦)");
String st = scan.nextLine();
if (st.equals("兔子")){
Point<String> p = new Point<>();
String[] str = {"🐇","韩韩","🐺","🐖","🐅","🦁"};
for (int i = 0; i <str.length ; i++) {
p.add(str[i]);
}
String str1 = p.getProduct();
System.out.println("恭喜你抽到了！"+str1);
}else if(st.equals("现金")){
Point<Integer> p1 = new Point<>();
int[] age = {10000,1000,100,10,1,0};
for (int i = 0; i <age.length ; i++) {
p1.add(age[i]);
}
Integer i = p1.getProduct();
System.out.println("您抽到了"+i+"块钱！");
}else {
System.out.println("你不配！滚吧");
}
}
}
5.集合操作
1.List接口是Collection的子接口，用于定义线性表数据结构；可以将List理解为存放对象的数组，只不过其元素个数可以动态的增加或减少。
2.ArrayList和LinkedList；List接口的两个常见实现类为ArrayList和LinkedList，
ArrayList:数组实现，查询性能更好
LinkedList:链表实现，增删性能更好，尤其首尾增删
3.//获取指定位置的元素 String str=list.get(int index);
//将给定元素位置到指定位置，返回值为原位置对应的元素
String old=list.set(1,“2”);
* List集合
* List是可重复集，并且有序
* 特点是：可以像数组一样，通过下标操作元素
* 并且也提供了一系列根据下标操作元素的方法
* @author rabbit
*/
public class List_Get_Set {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
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++) {
str = list.get(i);
System.out.println(str);
}
/**
* E set(int index,E e)
* 将给定元素设置到指定位置处，返回值
* 为原位置对应的元素。
*/
//[one,two,three,four,five]
String old = list.set(1,"2");
System.out.println(list);
System.out.println(old);
String sd = list.set(list.size()-1,"4" );
System.out.println(list);
System.out.println(sd);
list.add(list.size(),"5");
System.out.println(list);
}
}
//在当前集合指定位置插入指定元素
list.add(1,“2”);
//删除指定位置上的元素，返回值为被删除的元素
String old=list.remove(2);
/**
* List提供了一对重载的add,remove方法
* @author rabbit
*/
public class List_Add_Remove {
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);
/*
* void add(int index,E e)
* 向集合指定位置插入给定元素
*/
//[one,2,two,three,four]
list.add(1, "2");
System.out.println(list);
/*
* E remove(int index)
* 删除给定位置上的元素并将其返回
*/
//[one,2,three,four]
String old = list.remove(2);
System.out.println(list);
System.out.println(old);
}
}
//截取指定范围内的元素
List subList =list.subList(int start,int end);
//将子集元素扩大10倍
for(int i=0;i<subList.size();i++){
int n=subList.get(i);
n=n*10;
subList.set(i,n);｝
//删除list中2-8的元素
list.subList(2,9).clear();
/**
* 截取List集合的子集
* @author han
*
*/
public class List_Sublist {
public static void main(String[] args) {
List <Integer> list = new ArrayList<Integer>();
for(int i=0;i<10;i++){
list.add(i);
}
System.out.println("list"+list);
//取3-7 焊头不焊尾
List<Integer> subList = list.subList(3, 8);
System.out.println("sublist"+subList);
//将子集元素扩大10倍
for(int i=0;i<subList.size();i++){
subList.set(i,subList.get(i)*10);
// subList.set(i, subList.get(i) * 10);
}
System.out.println("sublist"+subList);
/*
* 对子集元素的操作就是对原集合相应内容的操作
*/
System.out.println("list"+list);
/*
* 删除3-7
*/
list.subList(3,8).clear();
System.out.println("list: "+list);
}
}
//Collection将集合转换为数组的方法：toArray
String[] array=c.toArray(new String[c.size()])
//集合转换为数组，Collection提供了方法：toArray
public class CollectionToArray {
public static void main(String[] args) {
Collection<String> c = new ArrayList<>();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
System.out.println(c);
//不常用
String[] array = c.toArray(new String[c.size()]);
System.out.println("len:"+array.length);
for (String str :array){
System.out.print(" "+str);
}
}
}
//将数组转换为List集合
List list=Arrays.asList(array)
/**
* 数组转换为集合
* 使用数组的工具类Arrays的静态方法asList
* 需要注意，只能将数组转换为List集合。
* @author rabbit
*/
public class ArraytoListCollection {
public static void main(String[] args) {
String[] array = {"one","two","three","four"};
List<String> list = Arrays.asList(array);
System.out.println(list.size()); //4
System.out.println(list);
/**
* 修改集合元素就是修改原数组对应元素
*/
list.set(1,"2");
System.out.println(list);
for (String str : array){
System.out.println(str);
}
/*
* 添加新元素会导致数组扩容，不允许这样
* 做，因为这样不能表示原数组了。
*/
// list.add("five");//会抛出异常
// System.out.println(list);
/*
* 若想添加新元素，可以自行实例化一个集合
*/
List<String> list1 = new ArrayList<String>(list);
// list1.addAll(list);
list1.add("five");
System.out.println(list1);
}
}
4.List对集合的排序
Collections.sort(list);
/**
* 使用集合的工具类Collections的静态方法
* sort可以对List集合进行自然排序(从小到大)
* reverse可以对List集合进行降序排序
* @author rabbit
*/
public class List_Sort {
public static void main(String[] args) {
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);
}
}
①Comparable
sort方法要求集合元素必须实现Comparable接口，Comparable 是在集合内部定义的方法实现的排序。
所有子类都需要重写该方法来定义对象间的比较规则。该方法要求返回一个整数，这个整数不关心具体的值，而是关注取值范围。
当返回值>0时，表示当前对象比参数给定的对象大。
当返回值<0时，表示当前对象比参数给定的对象小。
当返回值=0时，表示当前对象和参数给定的对象相等。
//使用该类测试自定义元素的集合排序
public class Point implements Comparable<Point>{
private int x;
private int y;
public Point(int x,int y){
super();
this.x = x;
this.y = 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;
}
/**
* 该方法的作用是用来判断当前对象this与
* 参数给定的对象o之间比较大小的。
* 返回值不关注具体取值，只关注取值范围，
* 当:
* 返回值>0:当前对象大于参数对象(this>o)
* 返回值<0:当前对象小于参数对象
* 返回值=0:两个对象相等
*/
@Override
public int compareTo(Point o) {
int len = this.x*this.x+this.y*this.y;
int olen = o.x*o.x+o.y*o.y;
return len-olen;
}
}
/**
* 自定义排序
*/
public class SortListDiv_Demo {
public static void main(String[] args) {
List<Point> list = new ArrayList<>();
list.add(new Point(5,2));
list.add(new Point(2,3));
list.add(new Point(3,4));
list.add(new Point(4,5));
/**
Collections的sort方法要求集合元素
必须实现Comparable接口。
有侵入性
*/
Collections.sort(list);
System.out.println(list);
}
}
②Comparator
Comparator 是在集合外部实现的排序
创建比较接口 如：比较规则:字符多的大
class MyComparator implements Comparator{
public int compare(String o1, String o2) {
return o1.length()-o2.length();}}
MyComparator com = new MyComparator();
Collections.sort(list, com);
/**
* 排序字符串,根据length
* @author Han
*/
public class SortListString_Demo {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("韩韩");
list.add("小韩韩rabbitsir");
list.add("没有脑袋");
System.out.println(list);
Comparator<String> com = new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length()-o2.length();
}
};
Collections.sort(list,com);
System.out.println(list);
}
}
5.队列和栈
队列，用于存放一组元素，但是队列对于存取要求必须遵循:先进先出原则
Queue queue= new LinkedList()；
queue.offer(“one”); 存入元素
queue.poll();获取队首元素，从队列中被删除
queue.peek();获取队首元素，不从队列中删除
迭代器遍历队列，元素不会减少
这种遍历元素减少while(queue.size()>0){
String s = queue.poll();
System.out.println(s);}
/**
*peek()引用队首元素
*poll()获取队首元素并移除
*offer()/add()添加元素
* 队列也可以存储一组元素，但是存取元素必须遵守先进先出原则
* @author rabbit
*/
public class QueueDemo {
public static void main(String[] args) {
Queue<String> queue = new LinkedList<>();
queue.add("哇呜呜");
//boolean offer(E e) 入队操作，向队列末尾追加新元素
queue.offer("offer");
queue.offer("offer");
queue.offer("offer");
queue.offer("offer");
System.out.println(queue);
//获取队首元素，获取后该元素即从队列中被移除 E poll()
System.out.println(queue.poll());
System.out.println(queue);
//引用队首元素，获取后但不从队列中删除 E peek()
System.out.println("引用队首元素"+queue.peek());
//遍历
for(String str :queue){
System.out.println("方式1"+str);
}
System.out.println("遍历方式1遍历完了"+queue);
while (queue.size()>0){
String str = queue.poll();
System.out.println("方式2"+str);
}
System.out.println("遍历完了："+queue);
}
}
栈，用于存放一组元素，元素存取必须遵循先进后出原则
使用栈通常为了解决有"后退"功能的需求中。栈可以使用双端队列实现。双端队列Deque,两端都可以进出队的队列。当仅从一段进出队时，就实现了栈的效果。
Deque stack= new LinkedList();
stack.push(“one”);存入元素
stack.poll();获取队首元素，从队列中被删除
stack.peek();获取队首元素，不从队列中删除
/**
* java.util.Deque双端队列，两端都可以进出队的队列，是Queue的子类。
* Deque接口规定了两端进出队的方法。
* 当仅调用从一端进出队的方法时，就形成了栈的结构特点
* void push(E e) 入栈操作 最后入栈的元素会在栈顶
* @author rabbit
*/
public class Stack {
public static void main(String[] args) {
Deque<String> stack = new LinkedList<>();
stack.offer("one");
stack.offer("two");
System.out.println(stack);//[one,two]
stack.offerLast("three");
System.out.println("offerLast队尾添加："+stack);//[one,two,three]
stack.offerFirst("four");
System.out.println("offerFrist队首添加："+stack);//[four,one,two,three]
String str = stack.poll();
System.out.println(str);//four
str = stack.peekLast();
System.out.println(str);//three
System.out.println(stack);//就剩个two了
System.out.println("--------------------------------");
//双端队列提供了入栈与出栈的方法
/*
* void push(E e)
* 入栈操作
* 最后入栈的元素会在栈顶
*/
stack.push("three");
stack.push("four");
stack.push("five");
System.out.println(stack);
/*
* E pop()
* 出栈操作
* 获取栈顶元素后该元素即从栈中被移除
*/
str = stack.pop();
System.out.println(str);//获取five并移除
System.out.println(stack);//这里没有了five
str = stack.peek();//引用队首元素
System.out.println(str);//输出队首元素
System.out.println(stack);//输出全部
for (String s : stack){//遍历队列
System.out.println(s);
}
System.out.println(stack);
}
}
CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！
更多推荐
0
0- 0
已为社区贡献1条内容
所有评论(0)