Java中的常用类

一、键盘录入相关类

1.System

1）系统类,提供了一些有用的字段和方法

2）成员方法(自己补齐)

A:运行垃圾回收器：void gc()

B:退出jvm：void exit(int status)

C:获取当前时间的毫秒值：long currentTimeMillis() 

D:数组复制：void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

2.Scanner的使用

1）在JDK5以后出现的用于键盘录入数据的类。

2）构造方法：

A：System.in其实是标准的输入流,对应于键盘录入

B：构造方法

InputStream is = System.in;

Scanner(InputStream is);

C：常用的格式

Scanner sc = new Scanner(System.in);

3）基本方法格式：

A:hasNextXxx() 判断是否是某种类型的

B:nextXxx()返回某种类型的元素

4）两个常用方法

A:public int nextInt()

B:public String nextLine()

5）注意：

同一个Scanner对象，先获取数值，再获取字符串会出现一个小问题。

解决方案：

a:重新定义一个Scanner对象

b:把所有的数据都用字符串获取，然后再进行相应的转换

二、字符串类

1.String类的概述和使用

1）多个字符组成的一串数据， 可以和字符数组进行相互转换。

2）构造方法：

A:public String()

B:public String(byte[] bytes)

C:public String(byte[] bytes,int offset,int length)

D:public String(char[] value)

E:public String(char[] value,int offset,int count)

F:public String(String original)

下面的这一个虽然不是构造方法，但是结果也是一个字符串对象

G:String s = "hello";

3）字符串的特点

A:字符串一旦被赋值，就不能改变。

注意：这里指的是字符串的内容不能改变，而不是引用不能改变。

B:字面值作为字符串对象和通过构造方法创建对象的不同

例：

String s = new String("hello");和String s = "hello";

第一个s是指向堆里的String对象，然后String对象指向字符串缓冲区

第二个是s直接指向字符串缓存区

4）字符串易错事例

A:==和equals()

                String s1 = new String("hello");
		String s2 = new String("hello");
		System.out.println(s1 == s2);// false，地址不同
		System.out.println(s1.equals(s2));// true，内容相同

		String s3 = new String("hello");
		String s4 = "hello";
		System.out.println(s3 == s4);// false，地址不同
		System.out.println(s3.equals(s4));// true，内容相同

		String s5 = "hello";
		String s6 = "hello";
		System.out.println(s5 == s6);// true，地址相同（都指向字符串缓冲区的同一地址）
		System.out.println(s5.equals(s6));// true，内容相同

B:字符串的拼接

		String s1 = "hello";
		String s2 = "world";
		String s3 = "helloworld";
		System.out.println(s3 == s1 + s2);// false
		System.out.println(s3.equals((s1 + s2)));// true

		System.out.println(s3 == "hello" + "world");// true,编译器编译时，会把所有常量之间的运算进行运算，此语句等效于s3 == "helloworld"
		System.out.println(s3.equals("hello" + "world"));// true

5）字符串的功能

A:判断功能

字符串是否相同：boolean equals(Object obj)

字符串忽略大小写后是否相同：boolean equalsIgnoreCase(String str)

字符串是否包含另外一个字符串：boolean contains(String str)

字符串是否以另外一个字符串开始：boolean startsWith(String str)

字符串是否以另外一个字符串结尾：boolean endsWith(String str)

字符串是否为空：boolean isEmpty()

B:获取功能

获取字符串长度：int length()

获取字符串指定索引处的字符：char charAt(int index)

获取字符串中第一次出现指定字符的索引位置：int indexOf(int ch)

获取字符串中第一次出现指定字符串的索引位置：int indexOf(String str)

获取字符串中从指定索引开始第一次出现指定字符的索引位置：int indexOf(int ch,int fromIndex)

获取字符串中从指定索引开始第一次出现指定字符串的索引位置：int indexOf(String str,int fromIndex)

截取start索引处和之后字符串：String substring(int start)

截取start和end索引之间的字符串（包括start，不包括end）：String substring(int start,int end)

C:转换功能

获取组成字符串的字节数组：byte[] getBytes()

获取组成字符串的字符数组：char[] toCharArray()

将字符数组转为字符串：static String valueOf(char[] chs)

将valueOf（）里面的值转为字符串：static String valueOf(int i)

将字符串转为小小：String toLowerCase()

将字符串转为大小：String toUpperCase()

在字符串转后面追加字符串：String concat(String str)

D:其他功能

a:替换功能 

String replace(char old,char new)

String replace(String old,String new)

b:去空格功能

String trim()

c:按字典比较功能

int compareTo(String str)

int compareToIgnoreCase(String str) 

2.StringBuffer、StringBuilder

1）用字符串做拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，Java就提供了

  一个字符串缓冲区类。StringBuffer，StringBuilder供我们使用。

StringBuilder与StringBuffer的区别仅在于StringBuffer是同步的，数据安全，效率低。StringBuilder是不同步的，数据不安全，效率高

下面只拿StringBuffer来讲

2）StringBuffer的构造方法

A:StringBuffer()

B:StringBuffer(int size)

C:StringBuffer(String str)

3）StringBuffer的常见功能

A:添加功能：StringBuffer append()，StringBuffer insert()

B:删除功能：StringBuffer delete(int start, int end)，StringBuffer deleteCharAt(int index)

C:替换功能：StringBuffer replace(int start, int end, String str)

D:反转功能：StringBuffer reverse() 

E:截取功能： String substring(int start)， String substring(int start,int end)

4）注意事项 ：

StringBuffer：同步的，数据安全，效率低。

StringBuilder：不同步的，数据不安全，效率高。

A：String,StringBuffer,StringBuilder的区别

String是定长的，全部存放于字符串缓冲区，StringBuffer,StringBuilder是可变的，数据存在堆中

B：StringBuffer和数组的区别?

数组只能存放某一类型的数据不好增加长度， StringBuffer可以存任意类型的数据，长度可变

String作为形式参数：和基本类型一样不会改变值

StringBuffer作为形式参数：会改变值

三、工具类

1.Arrays以及排序

1）排序

A:冒泡排序

相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。同理，其他的元素就可以排好。

public static void bubbleSort(int[] arr) {
		for (int x = 0; x < arr.length - 1; x++) {
			for (int y = 0; y < arr.length - 1 - x; y++) {
				if (arr[y] > arr[y + 1]) {
					int temp = arr[y];
					arr[y] = arr[y + 1];
					arr[y + 1] = temp;
				}
			}
		}
	}

B:选择排序

把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了0索引。同理，其他的元素就可以排好。

	public static void selectSort(int[] arr) {
		for (int x = 0; x < arr.length - 1; x++) {
			for (int y = x + 1; y < arr.length; y++) {
				if (arr[y] < arr[x]) {
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
				}
			}
		}
	}

2）查找

A:基本查找

针对数组无序的情况

	public static int getIndex(int[] arr, int value) {
		int index = -1;

		for (int x = 0; x < arr.length; x++) {
			if (arr[x] == value) {
				index = x;
				break;
			}
		}

		return index;
	}

B:二分查找(折半查找)

针对数组有序的情况(千万不要先排序，在查找)

	public static int binarySearch(int[] arr, int value) {
		int min = 0;
		int max = arr.length - 1;
		int mid = (min + max) / 2;

		while (arr[mid] != value) {
			if (arr[mid] > value) {
				max = mid - 1;
			} else if (arr[mid] < value) {
				min = mid + 1;
			}

			if (min > max) {
				return -1;
			}

			mid = (min + max) / 2;
		}

		return mid;
	}

3）Arrays工具类

A:是针对数组进行操作的工具类。包括排序和查找等功能。

B:要掌握的方法

把数组转成字符串：String toString(数组 a)

排序：void sort(数组 a) 

二分查找：int binarySearch(数组 a, byte key) ，int binarySearch(数组 a, int fromIndex, int toIndex, float key)

4）把字符串中的字符进行排序

例：

""abcdefg"

得到结果

"abcdefg"

/*
 * 把字符串中的字符进行排序。
 * 		举例："dacgebf"
 * 		结果："abcdefg"
 * 
 * 分析：
 * 		A:定义一个字符串
 * 		B:把字符串转换为字符数组
 * 		C:把字符数组进行排序
 * 		D:把排序后的字符数组转成字符串
 * 		E:输出最后的字符串
 */
public class ArrayTest {
	public static void main(String[] args) {
		// 定义一个字符串
		String s = "dacgebf";

		// 把字符串转换为字符数组
		char[] chs = s.toCharArray();

		// 把字符数组进行排序
		bubbleSort(chs);

		// 把排序后的字符数组转成字符串
		String result = String.valueOf(chs);

		// 输出最后的字符串
		System.out.println("result:" + result);
	}

	// 冒泡排序
	public static void bubbleSort(char[] chs) {
		for (int x = 0; x < chs.length - 1; x++) {
			for (int y = 0; y < chs.length - 1 - x; y++) {
				if (chs[y] > chs[y + 1]) {
					char temp = chs[y];
					chs[y] = chs[y + 1];
					chs[y + 1] = temp;
				}
			}
		}
	}
}

2.Math

1）针对数学运算进行操作的类

2）常见方法

A:绝对值：abs()

B:向上取整：ceil()

C:向下取整：floor()

D:两个数据中的大值：max()

E:a的b次幂：pow(double a, double b)

F:随机数：random()

G:四舍五入：round()

H:正平方根：sqrt()

3）案例：

获取任意范围的随机数

import java.util.Scanner;

/*
 * 需求：请设计一个方法，可以实现获取任意范围内的随机数。
 * 
 * 分析：
 * 		A:键盘录入两个数据。
 * 			int strat;
 * 			int end;
 * 		B:想办法获取在start到end之间的随机数
 * 			我写一个功能实现这个效果，得到一个随机数。(int)
 * 		C:输出这个随机数
 */
public class MathDemo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入开始数：");
		int start = sc.nextInt();
		System.out.println("请输入结束数：");
		int end = sc.nextInt();

		for (int x = 0; x < 100; x++) {
			// 调用功能
			int num = getRandom(start, end);
			// 输出结果
			System.out.println(num);
		}
	}

	/*
	 * 写一个功能 两个明确： 返回值类型：int 参数列表：int start,int end
	 */
	public static int getRandom(int start, int end) {
		// 回想我们讲过的1-100之间的随机数
		// int number = (int) (Math.random() * 100) + 1;
		// int number = (int) (Math.random() * end) + start;
		// 发现有问题了，怎么办呢?
		int number = (int) (Math.random() * (end - start + 1)) + start;
		return number;
	}
}

3.Random

1）用于产生随机数的类

2）构造方法:

A:Random() 默认种子，每次产生的随机数不同

B:Random(long seed) 指定种子，每次种子相同，随机数就相同

3）成员方法:

A:int nextInt() 返回int范围内的随机数

B:int nextInt(int n) 返回[0,n)范围内的随机数

四、其他类

1.Integer

1）为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型

byte            Byte

short          Short

int               Integer

long           Long

float           Float

double      Double

char          Character

boolean   Boolean

2）Integer的构造方法

A:Integer i = new Integer(100);

B:Integer i = new Integer("100");

注意：这里的字符串必须是由数字字符组成

3）String和int的相互转换

A:String -- int

Integer.parseInt("100");

B:int -- String

String.valueOf(100);

4）其他的功能

进制转换：

static String toBinaryString(int i)  二进制

static String toHexString(int i)   16进制

static String toOctalString(int i)    八进制

5）JDK5的新特性

自动装箱基本类型--引用类型

自动拆箱引用类型--基本类型

例：

Integer i = 100;//编译器会自动翻译成:Integer i = Integer.valueOf(100);

(6)注意：

Integer自带一个 -128到127之间的数据缓冲池，所有new的Integer在此范围内的，都指向此缓冲池，与String类似

2.Character

1）Character构造方法

Character ch = new Character('a');

2）要掌握的方法：

A:判断给定的字符是否是大写：static boolean isUpperCase()

B:判断给定的字符是否是小写：static boolean isLowerCase()

C:判断给定的字符是否是数字字符：static boolean isDigit()

D:把给定的字符转成大写：static boolean toUpperCase()

E:把给定的字符转成小写：static boolean toLowerCase()

3）案例：

统计字符串中大写，小写及数字字符出现的次数

import java.util.Scanner;

/*
 * 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
 * 
 * 分析：
 * 		A:定义三个统计变量。
 * 			int bigCont=0;
 * 			int smalCount=0;
 * 			int numberCount=0;
 * 		B:键盘录入一个字符串。
 * 		C:把字符串转换为字符数组。
 * 		D:遍历字符数组获取到每一个字符
 * 		E:判断该字符是
 * 			大写	bigCount++;
 * 			小写	smalCount++;
 * 			数字	numberCount++;
 * 		F:输出结果即可
 */
public class CharacterTest {
	public static void main(String[] args) {
		// 定义三个统计变量。
		int bigCount = 0;
		int smallCount = 0;
		int numberCount = 0;

		// 键盘录入一个字符串。
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串：");
		String line = sc.nextLine();

		// 把字符串转换为字符数组。
		char[] chs = line.toCharArray();

		// 历字符数组获取到每一个字符
		for (int x = 0; x < chs.length; x++) {
			char ch = chs[x];

			// 判断该字符
			if (Character.isUpperCase(ch)) {
				bigCount++;
			} else if (Character.isLowerCase(ch)) {
				smallCount++;
			} else if (Character.isDigit(ch)) {
				numberCount++;
			}
		}

		// 输出结果即可
		System.out.println("大写字母：" + bigCount + "个");
		System.out.println("小写字母：" + smallCount + "个");
		System.out.println("数字字符：" + numberCount + "个");
	}
}

3.BigInteger

1）针对大整数的运算

2）构造方法

A:BigInteger(String s)

3）成员方法(自己补齐)

A:加：BigInteger add(BigInteger val)

B:减：BigInteger subtract(BigInteger val)

C:乘：BigInteger multiply(BigInteger val)

D:除：BigInteger divide(BigInteger val)

E:商和余数：BigInteger[] divideAndRemainder(BigInteger val)

4.BigDecimal

1）浮点数据做运算，会丢失精度。所以，针对浮点数据的操作建议采用BigDecimal。(金融相关的项目)

2）构造方法

A:BigDecimal(String s)

3）成员方法：

A:加：BigDecimal add(BigDecimal augend)

B:减：BigDecimal subtract(BigDecimal subtrahend)

C:乘：BigDecimal multiply(BigDecimal multiplicand)

D:除：BigDecimal divide(BigDecimal divisor)

E:自己保留小数几位：BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)

5.Date/DateFormat

1）Date是日期类，可以精确到毫秒。

A:构造方法

Date()

Date(long time)

B:成员方法

long getTime()

long setTime(long time)

C:日期和毫秒值的相互转换

例：来到这个世界多少天

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/*
 * 算一下你来到这个世界多少天?
 * 
 * 分析：
 * 		A:键盘录入你的出生的年月日
 * 		B:把该字符串转换为一个日期
 * 		C:通过该日期得到一个毫秒值
 * 		D:获取当前时间的毫秒值
 * 		E:用D-C得到一个毫秒值
 * 		F:把E的毫秒值转换为年
 * 			/1000/60/60/24
 */
public class MyYearOldDemo {
	public static void main(String[] args) throws ParseException {
		// 键盘录入你的出生的年月日
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你的出生年月日:");
		String line = sc.nextLine();

		// 把该字符串转换为一个日期
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date d = sdf.parse(line);

		// 通过该日期得到一个毫秒值
		long myTime = d.getTime();

		// 获取当前时间的毫秒值
		long nowTime = System.currentTimeMillis();

		// 用D-C得到一个毫秒值
		long time = nowTime - myTime;

		// 把E的毫秒值转换为年
		long day = time / 1000 / 60 / 60 / 24;

		System.out.println("你来到这个世界：" + day + "天");
	}
}

2）DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，所以使用其子类SimpleDateFormat

A:SimpleDateFormat(String pattern) 给定模式

yyyy-MM-dd HH:mm:ss

B:日期和字符串的转换

a:Date -- String：利用SimpleDateFormat

format(Date date)

b:String -- Date：利用SimpleDateFormat

parse(String str)

6.Calendar

1）日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。

2）如何得到一个日历对象呢?

Calendar rightNow = Calendar.getInstance();

本质返回的是子类对象

3）成员方法

A:根据日历字段得到对应的值：get(Calendar.对应值)

B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值：add(Calendar.对应值, int)

C:设置日历对象的年月日：set()

4）案例：

计算任意一年的2月份的天数

import java.util.Calendar;
import java.util.Scanner;

/*
 * 获取任意一年的二月有多少天
 * 
 * 分析：
 * 		A:键盘录入任意的年份
 * 		B:设置日历对象的年月日
 * 			年就是A输入的数据
 * 			月是2
 * 			日是1
 * 		C:把时间往前推一天，就是2月的最后一天
 * 		D:获取这一天输出即可
 */
public class CalendarTest {
	public static void main(String[] args) {
		// 键盘录入任意的年份
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入年份：");
		int year = sc.nextInt();

		// 设置日历对象的年月日
		Calendar c = Calendar.getInstance();
		c.set(year, 2, 1); // 其实是这一年的3月1日
		// 把时间往前推一天，就是2月的最后一天
		c.add(Calendar.DATE, -1);

		// 获取这一天输出即可
		System.out.println(c.get(Calendar.DATE));
	}
}