Java常用类学习笔记

String

String:

package frequently.string;

public class Demo01 {
	public static void main(String[] args) {
		/*
		 * 1.String声明为final的，不可被继承
		 * 2.String实现了Serializable接口:表示字符串是支持序列化的
		 * 	 实现了Comparable接口:表示String 可以比较大小
		 * 3.String内部定义了final char[] value用于存储字符串数据
		 * 4.String:代表不可变的字符序列。简称:不可变性。
		 * 	  体现: 1. 当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值
		 *         2.当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
		 * 		   3.当调用String的replace()方法修改指定字符或字符串时，不能使用原有的value进行赋值
		 * 5.通过字面量的方式(区别于new)给一一个字符串赋值，此时的字符串值声明在字符串常量池中。
		 * 6.字符串常量池中是不会存储相同内容的字符串的。
		 */
		/*
		 * String的实例化方式:
		 * 方式一:通过字面量定义的方式
		 * 方式二:通过new +构造器的方式
		 * String s = new String("abc");方式创建对象，在内存中创建了几个对象?
		 * 两个:一个是堆空间中new结构，另-一个是char[ ]对应的常量池中的数据: "abc"
		 */
		//通过字面量定义的方式:此时的s1和s2的数据声明在方法区中的字符串常量池中。
		String s1="abc";//字面量的定义方式
		String s2="abc";
		System.out.println(s1==s2);//比较地址
		s1="hello";
		System.out.println(s1==s2);
		String s3="abc";
		s3+="def";
		System.out.println(s3==s2);
		String s4="abc";
		String s5=s4.replace('a','d');
		System.out.println(s5);
		System.out.println(s5==s2);
		//new +构造器的方式:此时存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
		String s6=new String();
		String s7=new String("hello");
		String s10=new String("hello");
		System.out.println(s2==s7);
		System.out.println(s10==s7);
		System.out.println(s10.equals(s10));
		String s8=new String(s1);
		char[] a= {'a','b','c','d','e'};
		String s9=new String(a,0,2);
		System.out.println(s6);
		System.out.println(s7);
		System.out.println(s8);
		System.out.println(s9);
		Person p1=new Person("Tom",11);
		Person p2=new Person("Tom",13);
		System.out.println(p1.name==p2.name);
		/*
		 * 常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
		 * 只要其中有一个是变量，结果就在堆中
		 * 如果拼接的结果调用intern()方法，返回值就在常量池中
		 */
		String sa="abc";
		String sb="def";
		String sc="abcdef";
		String sd="abc"+"def";
		String se=sa+"def";
		String sf="abc"+sb;
		String sh=sa+sb;
		final String sj="abc";
		String sk=sj+"def";
		//intern()返回值得到的si使用的常量池已经存在的"adcdef"
		String si=se.intern();
		System.out.println(sc==sd);//true
		System.out.println(sc==se);//false
		System.out.println(sc==sf);//false
		System.out.println(sc==sh);//false
		System.out.println(se==sf);//false
		System.out.println(si==sc);//true
		System.out.println(sk==sc);//true
	}
}

package frequently.string;

public class Person {
	String name;
	int age;
	public Person() {
		// TODO Auto-generated constructor stub
	}
	public Person(String name,int age) {
		// TODO Auto-generated constructor stub
		this.name=name;
		this.age=age;
	}
}

String与char[ ]的传递对比：

package frequently.string;

public class StringTest {
	String str=new String("good");
	char[] ch= {'t','e','s','t'};
	//（基本数据类型传递数据）
	//引用数据类型传递地址
	public void change(String str,char[] ch) {
		str="test ok";
		ch[0]='b';
	}
	public static void main(String[] args) {
		StringTest ex=new StringTest();
		ex.change(ex.str,ex.ch);
		System.out.println(ex.str);
		System.out.println(ex.ch);
	}
}

String的转换与拼接:

package frequently.string;
import java.util.Arrays;

public class StringTest1 {
	public static void main(String[] args) {
		StringTest1 s=new StringTest1();
		s.test1();
		s.test2();
		s.test3();
		s.test4();
	}
	public void test1() {
		String str1="123";
		int num=Integer.parseInt(str1);
		System.out.println(num);
		String str2=String.valueOf(num);
		String str3=str2+"";
		System.out.println(str1==str3);
	}
	public void test2() {
		String s1="abc123";
		char[] ch=s1.toCharArray();
		for(int i=0;i<ch.length;i++) {
			System.out.print(ch[i]+"\t");
		}
		System.out.println("");
		char[] ch1=new char[] {'h','i'};
		String s2=new String(ch1);
		System.out.println(s2);
	}
	public void test3(){
		String s1="abc123";
		byte[] b1=s1.getBytes();//使用默认字符集
		System.out.println(Arrays.toString(b1));
		String s2=new String(b1);
		System.out.println(s2);
	}
	public void test4() {
		String s1="hello";
		StringBuffer s2=new StringBuffer(s1);
		System.out.println(s2);
		String s3=s1.toString();
		System.out.println(s3);
		
	}
}

String常用方法：

package frequently.string;

public class StringMethodTset {
	/*
	 * int length(): 返回字符串的长度: return value. length
	 * char charAt(int index): 返回某索 引处的字符return value[index]
	 * boolean isEmpty(): 判断是否是空字符串: return value. Length ==0
	 * String tolowerCase(): 使用默认语言环境，将String中的所有字符转换为小写
	 * String toUpperCase(): 使用默认语言环境，将String中的所有字符转换为大写
	 * String trim(): 返回字符串的副本，忽略前导空白和尾部空白
	 * boolean equals(Object obj): 比较字符串的内容是否相同
	 * boolean equalsIgnoreCase(String anotherString): 与equals 方法类似，忽略大小写
	 * String concat(String str): 将指定字符串连接到此字符串的结尾。等价于用“+”
	 * int compareTo(String anotherString): 比较两个字符串的大小
	 * String substring(int beginIndex): 返回一个新的字符串，它是此字符串的从beginIndex开始截取
	 * String substring(int beginIndex,int endIndex) :返回-一个新字符串，它是此字符串从beginIndex-endIndex（不包括）的片段
	 * boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束
	 * boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始
	 * boolean startsWith(String prefix, int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始
	 * boolean contains(CharSequence S):当且仪当此子符串包含指定的char值序列时，返回true
	 * int indexOf(String str): 返回指定子字符串在此字符串中第一次出现 处的索引
	 * int indexOf(String str, int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
	 * int lastlndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引
	 * int lastiIndexOf(String str, int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
	 * indexOf和lastIndexOf方法如果未找到都是返回-1
	 * String replace(char oldChar, char newChar):返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar 得到的。
	 * String replace(CharSequence target, CharSequence replacement): 使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
	 * String replaceAl(String regex, String replacement): 使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串。
	 * String replaceFirst(String regex, String replacement): 使用给定的replacement替换此字符串匹配给定的正则表达式的第一一个 子字符串。
	 * boolean matches(String regex): 告知此字符串是否匹配给定的正则表达式。
	 * StringO split(String regex):根据给定正则表达式的匹配拆分此字符串。
	 * StringD split(String regex, int limit):根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一一个元素中。
	 */
	public static void main(String[] args) {
		StringMethodTset s=new StringMethodTset();
		s.test1();
	}
	public void test1() {
		String s1="helloworld";
		System.out.println(s1.charAt(5));
		String s2=s1.toUpperCase();
		System.out.println(s1);
		System.out.println(s2);
		String s3="   helloworld   ";
		String s4=s3.trim();
		System.out.println(s3);
		System.out.println(s4);
		String s5="abc";
		String s6=s5.concat(s2);
		System.out.println(s6);
		System.out.println(s1.compareTo(s2));
		String s7=s1.substring(2, 4);
		System.out.println(s7);
		System.out.println(s1.endsWith("world"));
		System.out.println(s1.startsWith("Hell"));
		System.out.println(s1.startsWith("llo", 2));
		System.out.println(s1.contains("wor"));
		System.out.println(s1.indexOf("o"));
		System.out.println(s1.indexOf("el",5));
		System.out.println(s1.lastIndexOf("o"));
		System.out.println(s1.lastIndexOf("ld", 7));
		String s8=s1.replace('o', 'e');
		System.out.println(s8);
		String s9=s1.replace("el", "e");
		System.out.println(s9);
		String s10="123dwd565few7e8";
		String s11=s10.replaceAll("\\d+", " ").replaceAll("^ | $", "");
		System.out.println(s11);
		String s12="0535-123456";
		System.out.println(s12.matches("0535-\\d{4,8}"));
		String s13="hell|jidw|jn";
		String[] s14=s13.split("\\|");
		for(int i=0;i<s14.length;i++) {
			System.out.println(s14[i]);
		}
	}
	
}

String. StringBuffer. StringBuilder：

package frequently.string;

public class StringBufferBuilderTest {
	/*
	 * String. StringBuffer. StringBuilder 三者的异同
	 * String:不可变的字符序列;底层采用char[]存储
	 * StringBuffer:可变的字符序列;线程安全的，效率低;底层采用char[]存储
	 * StringBuilder:可变的字符序列; jdk5. 日新增的，线程不安全的，效率高;底层采用char[]存储
	 * 对比String、StringBuffer. StringBuilder三者的效率:从高到低排列: StringBuilder > StringBuffer > String
	 */
	public static void main(String[] args) {
		StringBufferBuilderTest s=new StringBufferBuilderTest();
		s.test1();
		s.test2();
	}
	public void test1() {
		//开发中建议大家使用: StringBuffer(int capacity) 或StringBuffel:(int capacity)
		StringBuffer sb1=new StringBuffer("abc");
		sb1.setCharAt(0, 'm');
		System.out.println(sb1);
		System.out.println(sb1.length());
	}
	/*
	 * StringBuffer append(xxx):提供了很多的append()方法，用于进行字符串拼接
	 * StringBuffer delete(int start, int end): 删除指定位置的内容
	 * StringBuffer replace(int start, int end, String str): 把[start, end)位置替换为str
	 * StringBuffer insert(int offset, xxx): 在指定位置插入xxx
	 * StringBuffer reverse() :把当前字符序列逆转
	 * 增: append(xxx)
	 * 删: delete(int start, int end)
	 * 改: setCharAt(int n ,char ch) / replace(int start, int end, String str)
	 * 查: charAt(int n )
	 * 插: insert(int offset, xxx)
	 * 长度: Length();
	 * 遍历: for() + charAt()
	 */
	public void test2() {
		StringBuffer s1=new StringBuffer("abc");
		s1.append(1);
		s1.append('1');
		System.out.println(s1);
		s1.delete(1, 3);
		System.out.println(s1);
		s1.replace(1, 2, "qw");
		System.out.println(s1);
		s1.insert(2, "dad");
		System.out.println(s1);
		String s2=s1.substring(1,5);
		System.out.println(s2);
		
	}
}

获取两个字符串的最大相同子串:

 package frequently.string;

import java.util.Arrays;

/**
 * 获取两个字符串的最大相同子串
 * @author dell
 *
 */
public class MaxString {
	public static void main(String[] args) {
		String s1="abcwerthelloyouidefasablld";
		String s2="cvhellobnmablld";
		String s=new String();
		MaxString maxString=new MaxString();
		s=maxString.getMaxSameString(s1, s2);
		System.out.println(s);
		String[] s3=maxString.getMaxSameString1(s1, s2);
		System.out.println(Arrays.toString(s3));
	}
	//只有一个最长子串
	public String getMaxSameString(String s1,String s2) {
		if(s1!=null&&s2!=null) {
			String maxStr=(s1.length()>=s2.length())?s1:s2;
			String minStr=(s1.length()<s2.length())?s1:s2;
			int len=minStr.length();
			for(int i=0;i<len;i++) {
				for(int x=0,y=len-i;y<=len;x++,y++) {
					String subStr=minStr.substring(x, y);
					if(maxStr.contains(subStr)) {
						return subStr;
					}
				}
			}
		}
		
		return null;
	}
	//有多个
	public String[] getMaxSameString1(String s1,String s2) {
		StringBuffer s=new StringBuffer();
		if(s1!=null&&s2!=null) {
			String maxStr=(s1.length()>=s2.length())?s1:s2;
			String minStr=(s1.length()<s2.length())?s1:s2;
			int len=minStr.length();
			for(int i=0;i<len;i++) {
				for(int x=0,y=len-i;y<=len;x++,y++) {
					String subStr=minStr.substring(x, y);
					if(maxStr.contains(subStr)) {
						s.append(subStr+",");
					}
				}
				if(s.length()!=0) {
					break;
				}
			}
		}
		String[] aplit=s.toString().replace(",$", "").split("\\,");
		return aplit;
	}

}

小例子：

package frequently.string;

public class PrintStr {
	public static void main(String[] args) {
		String str=null;
		StringBuffer sb=new StringBuffer();
		sb.append(str);
		System.out.println(sb.length());
		System.out.println(sb);
		//StringBuffer sb1=new StringBuffer(str);
		//System.out.println(sb1.length());
		//System.out.println(sb1);
	}
}

Date

package frequently.date;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;
import java.util.Calendar;
import java.util.Date;

public class DateTest {
	public static void main(String[] args) {
		DateTest d=new DateTest();
		d.test1();
		d.test2();
		d.test3();
		d.test4();
		d.test5();
		d.test6();
		d.test7();
		d.test8();
	}
	public void test1() {
		long time=System.currentTimeMillis();
		System.out.println(time);
	}
	public void test2() {
		//创建一个对应当前时间的Date对象
		Date date1=new Date();
		System.out.println(date1.toString());
		System.out.println(date1.getTime());
		创建一个指定时间的Date对象
		Date date2=new Date(1627022512552L);
		System.out.println(date2.toString());
		Date date3=new java.sql.Date(1627022512552L);
		System.out.println(date3.toString());
		Date date4=new java.sql.Date(1627022512552L);
		java.sql.Date date5=(java.sql.Date) date4;
		System.out.println(date5.toString());
		java.sql.Date date6=new java.sql.Date(date1.getTime());
		System.out.println(date6.toString());
	}
	public void test3(){
		//使用默认的构造器
		SimpleDateFormat sdf=new SimpleDateFormat();
		Date date=new Date();
		String s=sdf.format(date);
		System.out.println(s);
		String str="21-7-23 下午6:40";
		Date date1;
		try {
			date1 = sdf.parse(str);
			System.out.println(date1);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		SimpleDateFormat sdf1=new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
		String s1=sdf1.format(date);
		System.out.println(s1);
		Date date2;
			try {
				date2 = sdf1.parse(s1);
				System.out.println(date2);
			} catch (ParseException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}
	public void test4() {
		//Calendar实例化
		//1.创建其子类（GregorianCalendar）的对象
		//2.调用其静态方法getInstance
		//获取月份时，1月是0，获取星期时，周日是1
		Calendar calendar=Calendar.getInstance();
		//System.out.println(calendar.getClass());
		//get
		int days=calendar.get(Calendar.DAY_OF_MONTH);
		System.out.println(days);
		//set
		calendar.set(Calendar.DAY_OF_MONTH, 11);
		days=calendar.get(Calendar.DAY_OF_MONTH);
		System.out.println(days);
		//add
		calendar.add(Calendar.DAY_OF_MONTH, 3);
		days=calendar.get(Calendar.DAY_OF_MONTH);
		System.out.println(days);
		calendar.add(Calendar.DAY_OF_MONTH, -3);
		days=calendar.get(Calendar.DAY_OF_MONTH);
		System.out.println(days);
		//getTime
		Date date=calendar.getTime();
		System.out.println(date);
		//setTime
		Date date1=new Date();
		calendar.setTime(date1);
		days=calendar.get(Calendar.DAY_OF_MONTH);
		System.out.println(days);
	}
	public void test5() {
		//偏移量问题
		//Date date1=new Date(2021-1900,7-1,23);
		//System.out.println(date1);
	}
	public void test6() {
		//now获取当前日期、时间
		LocalDate localdate=LocalDate.now();
		LocalTime localtime=LocalTime.now();
		LocalDateTime localDatetime=LocalDateTime.now();
		System.out.println(localdate);
		System.out.println(localtime);
		System.out.println(localDatetime);
		//of,没有偏移量
		LocalDateTime localDateTime1=LocalDateTime.of(2020,10,1,13,23,43);
		System.out.println(localDateTime1);
		//get
		System.out.println(localDatetime.getDayOfMonth());
		//with,体现不可变性
		LocalDate localDate1=localdate.withDayOfMonth(1);
		System.out.println(localdate);
		System.out.println(localDate1);
		LocalDateTime localDateTime3=localDatetime.plusMonths(3);
		System.out.println(localDatetime);
		System.out.println(localDateTime3);
		LocalDateTime localDateTime4=localDatetime.minusMonths(3);
		System.out.println(localDatetime);
		System.out.println(localDateTime4);
	}
	public void test7() {
		Instant instant=Instant.now();//本初子午线
		System.out.println(instant);
		//添加时间的偏移量
		OffsetDateTime offsetDateTime= instant.atOffset(ZoneOffset.ofHours(8));
		System.out.println(offsetDateTime);
		//获取自1970.1.1 0：0：0开始对应的毫秒数
		long lli =instant.toEpochMilli();
		System.out.println(lli);
		Instant instant2= Instant.ofEpochMilli(1627044270406L);
		System.out.println(instant2);
	}
	//DateTimeFormat：格式化或者解析日期、时间
	public void test8() {
		//预定义的标准格式。如: ISO_ LOCAL_ DATE_ TIME;ISO_ LOCAL_ DATE;ISO_ _LOCAL _TIME
		DateTimeFormatter formatter=DateTimeFormatter.ISO_LOCAL_TIME;
		//格式化:日期-->字符串
		LocalDateTime localDateTime=LocalDateTime.now();
		String s1=formatter.format(localDateTime);
		System.out.println(localDateTime);
		System.out.println(s1);
		//本地化相关的格式。如: ofLocalizedDateTime(Formatstyle . LONG)_
		DateTimeFormatter formatter2= DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
		String s2=formatter2.format(localDateTime);
		System.out.println(s2);
		DateTimeFormatter formatter3=DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
		String s3=formatter3.format(LocalDate.now());
		System.out.println(s3);
		//自定义的格式如: ofPattern("xyyy-MM-dd. hh:mm:ss E2)
		DateTimeFormatter formatter4= DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
		String s4=formatter4.format(LocalDateTime.now());
		System.out.println(s4);
		TemporalAccessor accessor= formatter4.parse("2021-07-23 09:13:20");
		System.out.println(accessor);
	}
}

排序

package frequently.compare;

import java.util.Arrays;
import java.util.Comparator;

/*
 * 二、Comparable接口与Comparator的使用的对比:
 * Comparable接口的方式一旦一 定， 保证Comparable 接口实现类的对象在任何位置都可以比较大小
 * Comparator接口属于临时性的比较。
 */
public class CompareTest {
	public static void main(String[] args) {
		CompareTest test=new CompareTest();
		test.test1();
		test.test2();
		test.test3();
		test.test4();
	}
	/*
	Comparable接口的使用举例:
	1.像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式
	2.像String、包装类重写compareTo()方法以后，进行了从小到大的排列
	3.重写compareTo(obj) 的规则:
	如果当前对象this大于形参对象obj,则返回正整数，
	如果当前对象this小于形参对象obj,则返回负整数，
	如果当前对象this等于形参对象obj,则返回零。
	4.对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法。
	在compareTo(obj)方法中指明如何排序
	*/
	public void test1() {
		//Comparable接口的使用
		String[] arr=new String[] {"aa","dw","qs","as","wd"};
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
	}
	public void test2() {
		Goods[] arr=new Goods[4];
		arr[0]=new Goods("aa",12);
		arr[1]=new Goods("ba",12);
		arr[2]=new Goods("ra",34);
		arr[3]=new Goods("ra",11);
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
	}
	/*
	Comparator接口的使用:定制排序
	1.背景:
	当元素的类型没有实现java.Lang.Comparable接口而又不方便修改代码,I
	或者实现了java.Lang.Comparable接口的排序规则不适合当前的操作，
	那么可以考虑使用Comparator的对象来排序
	2.重写compare(Object 01, object 02)方法，比较o1 和o2的大小:
	如果方法返回正整数，则表示1大Fo2;
	如果返回e，表示相等;
	返回负整数，表示o1小Fo2。
	*/
	public void test3() {
		String[] arr=new String[] {"aa","dw","qs","as","wd"};
		//按照字符串从大到小的顺序进行排列
		Arrays.sort(arr,new Comparator<Object>() {
			@Override
			public int compare(Object o1, Object o2) {
				// TODO Auto-generated method stub
				if (o1 instanceof String&&o2 instanceof String) {
					String s1=(String)o1;
					String s2=(String)o2;
					return -s1.compareTo(s2);
				}
				//return 0;
				throw new RuntimeException("数据类型不一致");
			}
			
		});
		System.out.println(Arrays.toString(arr));
	}
	public void test4() {
		Goods[] arr=new Goods[4];
		arr[0]=new Goods("aa",12);
		arr[1]=new Goods("ba",12);
		arr[2]=new Goods("ra",34);
		arr[3]=new Goods("ra",11);
		Arrays.sort(arr,new Comparator<Object>() {

			@Override
			public int compare(Object o1, Object o2) {
				// TODO Auto-generated method stub
				if(o1 instanceof Goods&&o2 instanceof Goods) {
					Goods g1=(Goods)o1;
					Goods g2=(Goods)o2;
					if(g1.getName().equals(g2.getName())) {
						return -Double.compare(g1.getPrice(), g2.getPrice());
					}else {
						return g1.getName().compareTo(g2.getName());
					}
				}
				//return 0;
				throw new RuntimeException("数据类型不一致");
			}
		});
		System.out.println(Arrays.toString(arr));
	}
}


```java
package frequently.compare;

public class Goods implements Comparable<Object>{
	private String name;
	private double price;
	public Goods() {
		// TODO Auto-generated constructor stub
	}
	public Goods(String string, double i) {
		// TODO Auto-generated constructor stub
		this.name=string;
		this.price=i;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "Goods{name="+name+'\''+",price="+price+'}';
	}
	//指明排序方式
	@Override
	public int compareTo(Object o) {
		// TODO Auto-generated method stub
		if (o instanceof Goods) {
			Goods goods=(Goods)o;
			if(this.price>goods.price) {
				return 1;
			}
			else if (this.price<goods.price) {
				return -1;
			}
			else {
				//return 0;
				return this.name.compareTo(goods.name);
				//return -this.name.compareTo(goods.name);
			}
			//return Double.compare(this.price, goods.price);
		}
		//return 0;
		throw new RuntimeException("数据类型不一致");
	}
}

System,BigInteger,BigDecimal

package frequently.other;

import java.math.BigDecimal;
import java.math.BigInteger;

public class Other {
	public static void main(String[] args) {
		Other other=new Other();
		other.test1();
		other.test2();
	}
	public void test1() {
		String javaVersion = System. getProperty("java.version");
		System. out . println("java的version:" + javaVersion);
		String javaHome = System. getProperty("java.home");
		System. out . println("java的home:" + javaHome);
		String osName = System. getProperty("os .name");
		System. out. println("os的name:" + osName);
		String osVersion = System. getProperty("os.version");
		System. out . println("os的version:" + osVersion); 
		String userName = System. getProperty( "user.name");
		System. out . println("user的name:" + userName);
		String userHome = System. getProperty("user.home");
		System. out. println("user的home:" + userHome);
		String userDir = System. getProperty("user.dir");
		System. out. println("user的dir:" + userDir);
	}
	public void test2() {
		BigInteger bi =new BigInteger("12433241123");
		BigDecimal bd =new BigDecimal("12345.351");
		BigDecimal bd1 =new BigDecimal("11");
		System.out.println(bi);
		//System.out.println(bd.divide(bd1));
		System.out.println(bd.divide(bd1,BigDecimal.ROUND_HALF_UP));
		System.out.println(bd.divide(bd1,25,BigDecimal.ROUND_HALF_UP));
	}
}

枚举类

package frequently.enumclass;

/**
  * 一.枚举类的使用
 * 1.枚举类的理解:类的对象只有有限个，确定的。我们称此类为枚举类
 * 2.当需要定义一组常量时， 强烈建议使用枚举类中
 * 3.如果校举类中只有一个对象，则可以作为单例模式的实现方式。
  * 二.如何定义枚举类
  * 方式一: jdk5.0之前，自定义枚举类I
  * 方式二: jdk5.0之后， 可以使用enum关键字定义枚举类
  * 三、Enum类中的常用方法: .
 * values()方法:返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
 * value0f(String str): 可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象
 * tostring(): 返回当前枚举类对象常量的名称
  * 四、使用enum关键字定义的枚举类实现接口的情况
  * 情况一:实现接口，在enum类中实现抽象方法
  * 情况二:让枚举类的对象分别实现接口中的抽象方法
 * @author dell
 *
 */

public class SeasonTest {
	public static void main(String[] args) {
		Season season= Season.SPRING;
		System.out.print(season);
	}
}
//自定义枚举类
class Season{
	//1.声明Season对象的属性
	private final String seasonName;
	private final String seasonDesc;
	
	//2.私有化的构造器，并给对象属性复制
	private Season(String name,String desc) {
		// TODO Auto-generated constructor stub
		this.seasonName=name;
		this.seasonDesc=desc;
	}
	
	//3.提供当前枚举类的多个对象
	public static final Season SPRING=new Season("春天", "春暖花开");
	public static final Season SUMMER=new Season("夏天", "夏日炎炎");
	public static final Season AUTUMN=new Season("秋天", "秋高气爽");
	public static final Season WINTER=new Season("冬天", "冰天雪地");
	
	//4.其他诉求，获取枚举类对象的属性,提供tostring方法
	public String getSeasonName() {
		return seasonName;
	}
	public String getSeasonDesc() {
		return seasonDesc;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		//return super.toString();
		 return "Season:"+seasonName+"--"+seasonDesc;
	}
}

package frequently.enumclass;

import java.util.Arrays;

public class SeasonTest1 {
	public static void main(String[] args) {
		Season1 season= Season1.SUMMER;
		System.out.println(season);
		Season1[] season1s=Season1.values();
		System.out.println(Arrays.toString(season1s));
		//如果没有WINTER则抛出异常
		Season1 winter=Season1.valueOf("WINTER");
		System.out.println(winter);
		winter.show();
	}
}

interface Info{
	void show();
}
//使用enum关键字
enum Season1 implements Info{
	//提供当前枚举类的对象
	SPRING("春天", "春暖花开"){
		@Override
		public void show() {
			// TODO Auto-generated method stub
		}
	},
	SUMMER("夏天", "夏日炎炎"){
		@Override
		public void show() {
			// TODO Auto-generated method stub
		}
	},
	AUTUMN("秋天", "秋高气爽"){
		@Override
		public void show() {
			// TODO Auto-generated method stub
			
		}
	},
	WINTER("冬天", "冰天雪地"){
		@Override
		public void show() {
			// TODO Auto-generated method stub
			System.out.print("冬天到了");
		}
	};
	private final String seasonName;
	private final String seasonDesc;
	private Season1(String name,String desc) {
		// TODO Auto-generated constructor stub
		this.seasonName=name;
		this.seasonDesc=desc;
	}
	public String getSeasonName() {
		return seasonName;
	}
	public String getSeasonDesc() {
		return seasonDesc;
	}
	/*public void show() {
		// TODO Auto-generated method stub
		System.out.println("这是一个季节");
	}*/
}