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[b]以及排序[/b]

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));
}
}