黑马程序员—java基础—常用API
2015-11-29 10:57
621 查看
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
API贯穿java学习的始末，使用API正是面向对象编程的一种体现，整理一些常用的API，供以后复习方便
关于Eclipse的使用因为贯穿在每一天的代码练习中，这里就不做记录。
API的概述
Java API
就是Java提供给我们使用的类，这些类将底层的实现封装了起来，
我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。
常用类
Object类/Scanner类
String类/StringBuffer类/StringBuilder类
数组高级和Arrays类
基本类型包装类(Integer,Character)
正则表达式(Pattern,Matcher)
Math类/Random类/System类
BigInteger类/BigDecimal类
Date类/DateFormat类/Calendar类
一，Object类
Object类概述
类层次结构的根类
所有类都直接或者间接的继承自该类
主要方法例举：：
public int hashCode()
a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
b:不同对象的，hashCode()一般来说不会相同。
但是，同一个对象的hashCode()值肯定相同。
c:不是对象的实际地址值，可以理解为逻辑地址值。
举例：物体和编号。
public final Class getClass()
a:返回此 Object 的运行时类。
b:可以通过Class类中的一个方法，获取对象的真实类的全名称。
public String getName() //搭配使用
public String toString()
a:返回该对象的字符串表示。
底层源码。
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}
b:它的值等于：
getClass().getName() + '@' + Integer.toHexString(hashCode())
c:由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
这些方法，在Eclipse里面可以自动生成
equals()
a:指示其他某个对象是否与此对象“相等”。
b:默认情况下比较的是对象的引用是否相同。
c:由于比较对象的引用没有意义，一般建议重写该方法。
二.scanner类
A:Scanner的概述
JDK5以后获取用户的键盘录入
B:Scanner的构造方法原理
Scanner(InputStream source)
System类下有一个静态的字段：
public static final InputStream in; 标准的输入流，对应着键盘录入。（IO流就学到了）
方法概述：
hasNextXxx()和nextXxx()
hasNextXxx() 判断是否还有下一个输入项,其中Xxx可以是Int,Double等。
如果需要判断是否包含下一个字符串，则可以省略Xxx
nextXxx() 获取下一个输入项。Xxx的含义和上个方法中的Xxx相同
默认情况下，Scanner使用空格，回车等作为分隔符
public int nextInt():获取一个int类型的值
public String nextLine():获取一个String类型的值
三，String类
String，就是用途最广泛的字符串，查阅API，String有以下两个特点：
a:字符串字面值"abc"也可以看成是一个字符串对象。
b:字符串是常量，一旦被赋值，就不能被改变。
常见构造方法
public String():空构造
public String(byte[] bytes):把字节数组转成字符串
public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
public String(char[] value):把字符数组转成字符串
public String(char[] value,int index,int count):把字符数组的一部分转成字符串
public String(String original):把字符串常量值转成字符串
常见方法：
public int length()：返回此字符串的长度。
String s = "hello"; s += "world"; 问s的结果是多少?
分析：结果是helloworld。字符串存储在常量池。字符串的内容是不可变的，但是引用可变。
String s = new String(“hello”)和String s = “hello”;的区别
分析：区别是，第一个写法创建了2个对象，第二个写法创建了一个对象
String类的判断功能
boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
boolean contains(String str):判断大字符串中是否包含小字符串
boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
boolean isEmpty():判断字符串是否为空。
Stirng类的判断功能演示：
API贯穿java学习的始末，使用API正是面向对象编程的一种体现，整理一些常用的API，供以后复习方便
关于Eclipse的使用因为贯穿在每一天的代码练习中，这里就不做记录。
API的概述
Java API
就是Java提供给我们使用的类，这些类将底层的实现封装了起来，
我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。
常用类
Object类/Scanner类
String类/StringBuffer类/StringBuilder类
数组高级和Arrays类
基本类型包装类(Integer,Character)
正则表达式(Pattern,Matcher)
Math类/Random类/System类
BigInteger类/BigDecimal类
Date类/DateFormat类/Calendar类
一，Object类
Object类概述
类层次结构的根类
所有类都直接或者间接的继承自该类
主要方法例举：：
public int hashCode()
a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
b:不同对象的，hashCode()一般来说不会相同。
但是，同一个对象的hashCode()值肯定相同。
c:不是对象的实际地址值，可以理解为逻辑地址值。
举例：物体和编号。
public final Class getClass()
a:返回此 Object 的运行时类。
b:可以通过Class类中的一个方法，获取对象的真实类的全名称。
public String getName() //搭配使用
public String toString()
a:返回该对象的字符串表示。
底层源码。
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}
b:它的值等于：
getClass().getName() + '@' + Integer.toHexString(hashCode())
c:由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
这些方法，在Eclipse里面可以自动生成
equals()
a:指示其他某个对象是否与此对象“相等”。
b:默认情况下比较的是对象的引用是否相同。
c:由于比较对象的引用没有意义，一般建议重写该方法。
二.scanner类
A:Scanner的概述
JDK5以后获取用户的键盘录入
B:Scanner的构造方法原理
Scanner(InputStream source)
System类下有一个静态的字段：
public static final InputStream in; 标准的输入流，对应着键盘录入。（IO流就学到了）
方法概述：
hasNextXxx()和nextXxx()
hasNextXxx() 判断是否还有下一个输入项,其中Xxx可以是Int,Double等。
如果需要判断是否包含下一个字符串，则可以省略Xxx
nextXxx() 获取下一个输入项。Xxx的含义和上个方法中的Xxx相同
默认情况下，Scanner使用空格，回车等作为分隔符
public int nextInt():获取一个int类型的值
public String nextLine():获取一个String类型的值
三，String类
String，就是用途最广泛的字符串，查阅API，String有以下两个特点：
a:字符串字面值"abc"也可以看成是一个字符串对象。
b:字符串是常量，一旦被赋值，就不能被改变。
常见构造方法
public String():空构造
public String(byte[] bytes):把字节数组转成字符串
public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
public String(char[] value):把字符数组转成字符串
public String(char[] value,int index,int count):把字符数组的一部分转成字符串
public String(String original):把字符串常量值转成字符串
常见方法：
public int length()：返回此字符串的长度。
String s = "hello"; s += "world"; 问s的结果是多少?
分析：结果是helloworld。字符串存储在常量池。字符串的内容是不可变的，但是引用可变。
String s = new String(“hello”)和String s = “hello”;的区别
分析：区别是，第一个写法创建了2个对象，第二个写法创建了一个对象
String类的判断功能
boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
boolean contains(String str):判断大字符串中是否包含小字符串
boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
boolean isEmpty():判断字符串是否为空。
Stirng类的判断功能演示：
public class StringDemo {
public static void main(String[] args) {
String s1 = "woaidongmei";
String s2 = "woaidongmei";
String s3 = "WoaiDongMei";
//boolean equals(Object obj)
System.out.println("equals:"+s1.equals(s2));
System.out.println("equals:"+s1.equals(s3));
System.out.println("-------------------------------------");
//boolean equalsIgnoreCase(String str)
System.out.println("equalsIgnoreCase:"+s1.equalsIgnoreCase(s2));
System.out.println("equalsIgnoreCase:"+s1.equalsIgnoreCase(s3));
System.out.println("-------------------------------------");
//boolean contains(String str)
System.out.println("contains:"+s1.contains("w"));
System.out.println("contains:"+s1.contains("dong"));
System.out.println("contains:"+s1.contains("Woai"));
System.out.println("contains:"+s1.contains("hello"));
System.out.println("-------------------------------------");
//boolean startsWith(String str):
System.out.println("startsWith:"+s1.startsWith("w"));
System.out.println("startsWith:"+s1.startsWith("woai"));
System.out.println("startsWith:"+s1.startsWith("Woai"));
System.out.println("startsWith:"+s1.startsWith("dong"));
System.out.println("-------------------------------------");
//boolean isEmpty()
System.out.println("isEmpty:"+s1.isEmpty());
String s4 = "";
//String s5 = null;
System.out.println("s4:isEmpty:"+s4.isEmpty());
//System.out.println("s5:isEmpty:"+s5.isEmpty());//NullPointerException
String s6 = " ";
System.out.println("s6:isEmpty:"+s6.isEmpty());
}
}
<
4000
/pre>
String类的获取功能
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):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
String substring(int start):从指定位置开始截取字符串,默认到末尾。
String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。包首不包尾
可以顺带提一下lastIndexOf系列:返回指定字符在此字符串中最后一次出现处的索引。
经典案例分析：需求：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
public class StringTest2 {
public static void main(String[] args) {
//定义一个字符串
String s = "Jin12H5u6LuWa";
//定义统计变量
int bigCount = 0;
int smallCount = 0;
int numCount = 0;
//遍历字符串 拿到每一个字符
for (int i = 0; i < s.length(); i++) {
//每一个字符是 s.charAt(i)
if ('0'<=s.charAt(i) && s.charAt(i)<='9') {
numCount++;
} else if('A'<=s.charAt(i) && s.charAt(i)<='Z'){
bigCount++;
}else if ('a'<=s.charAt(i) && s.charAt(i)<='z') {
smallCount++;
}
}
System.out.println("大写字母有"+bigCount+"个;");
System.out.println("小写字母有"+smallCount+"个;");
System.out.println("数字有"+numCount+"个.");
}
}
String的转换功能：
byte[] getBytes():把字符串转换为字节数组。
char[] toCharArray():把字符串转换为字符数组。
static String valueOf(char[] chs):把字符数组转成字符串。
static String valueOf(int i):把int类型的数据转成字符串。
String toLowerCase():把字符串转成小写。
String toUpperCase():把字符串转成大写。
String concat(String str):把字符串拼接。
注意：String类的valueOf方法可以把任意类型的数据转成字符串。（方法重载）
String类的其他的一些功能：
String replace(char old,char new)
String replace(String old,String new)//替换功能
String trim() 去除字符串两端的空格，不去除中间的
int compareTo(String str)
int compareToIgnoreCase(String str) 按字典顺序比较字符串
字符串一个超级经典的案例题： woaidongmeidongmeiaiwodongmeidongmeiwoaini 统计dongmei出现的次数
package cn.itcast_08;
/*
* 分析:
* woaidongmeidongmeiaiwodongmeidongmeiwoaini
* 1: 定义一个统计变量
2:先在大串中找小串,找到
通过 indexOf() 方法 返回值 -1,找不到
返回值不是-1,找到
统计变量++
继续找
3:需要一个新的大串了,拿到刚才的索引地址+小串长度就是新串的起 始位置 subString(索引地址+小串长度);
继续查找 通过indexOf 重复第二步
返回值为-1的时候.
不知道次数选择while()循环
*/
public class StringTest2 {
public static void main(String[] args) {
//定义一个字符串
String bigString = "woaidongmeidongmeiaiwodongmeidongmeiwoaini";
//要查找dongmei出现的次数
String smallString = "dongmei";
//统计变量
int count =0;
//查看小字符串是否在大字符串中存在
int index = bigString.indexOf(smallString);
//用while循环实现
while (index!=-1) {
count++;
int beginIndex = index+smallString.length();
bigString = bigString.substring(beginIndex);
//在去查找
index = bigString.indexOf(smallString);
}
System.out.println("count:"+count);
}
}
四，StringBuffer类
该类是字符串缓冲区，还有一个字符串缓冲区类是StringBulider，其实功能一样，只是StringBuffer线程是安全的
构造方法：
StringBuffer的构造方法：
public StringBuffer():构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
public StringBuffer(int capacity):构造一个不带字符，但具有指定初始容量的字符串缓冲区。
public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
B:StringBuffer的方法：
public int capacity()：返回当前容量。 理论值 （包括未被使用的缓冲区）
public int length():返回长度（字符数）。 实际值
StringBuffer的添加功能
public StringBuffer append(String str):(做拼接)
可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
public StringBuffer insert(int offset,String str):
在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
注意，这里有一句话很重要：并返回字符串缓冲区本身。示例演示：
/*
* StringBuffer添加功能
* public StringBuffer append(String str):
* 可以把任意类型数据追加到字符串缓冲区里面(添加到末尾)
* 并返回字符串缓冲区本身
* public StringBuffer insert(int index,String str):
* 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
*/
public class StringBufferDemo2 {
public static void main(String[] args) {
StringBuffer sb =new StringBuffer();
// StringBuffer sb2 = sb.append("hello");
// System.out.println(sb2);//hello
// System.out.println(sb); //hello
// System.out.println(sb==sb2);
//public StringBuffer append(String str)
//链式编程
//System.out.println(sb.append("hello").append("world").append("aaa"));
sb.append("hello");
sb.append(123);
sb.append(true);
sb.append(3.2);
//想要在hello后面 插入一个world
//public StringBuffer insert(int index,String str)
//这里的索引是你要插入字符串的起始位置
sb.insert(5, "world");
System.out.println(sb);
System.out.println("sb.capacity()"+sb.capacity());
System.out.println("sb.length():"+sb.length());
}
}
StringBuffer的删除功能
public StringBuffer deleteCharAt(int index):
删除指定位置的字符，并返回本身
public StringBuffer delete(int start,int end):
删除从指定位置开始指定位置结束的内容，并返回本身StringBuffer的删除功能
public StringBuffer deleteCharAt(int index):
删除指定位置的字符，并返回本身
public StringBuffer delete(int start,int end):
删除从指定位置开始指定位置结束的内容，并返回本身
StringBuffer的替换功能
public StringBuffer replace(int start,int end,String str):
从start开始到end用str替换
StringBuffer的反转功能
public StringBuffer reverse():
字符串反转
StirngBuffer类的截取功能，这个简直太重要了
StringBuffer的截取功能
public String substring(int start):
从指定位置截取到末尾
public String substring(int start,int end):
截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
返回的是一个新的字符串
五。Arrays类
重点：排序算法
1，冒泡排序：
冒泡排序是：相邻两个元素比较,大的往后放, 第一比较完最大值就放到最大索引处了 冒泡排序图：
选择排序：从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处
选择排序图：
代码实现：
package cn.itcast.ArraysTool;
/*
* 排序
* 冒泡排序:
* 相邻两个元素比较,大的往后放, 第一比较完最大值就放到 最大索引处了
*
* 实现:
*
*
*
*/
public class ArraysDemo {
public static void main(String[] args) {
int[] arr ={24,69,80,57,13};
printArr(arr);
//做一个冒泡排序
//bubbleSort(arr);
//做一个选择排序的方法
searchSort(arr);
printArr(arr);
}
//选择排序:
public static void searchSort(int[] arr) {
//写一个循环 外层循环控制循环次数
for (int i = 0; i < arr.length-1; i++) {
//内层循环控制参与比较的元素
for (int j = i+1; j < arr.length; j++) {
if (arr[i]>arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
//冒泡排序
public static void bubbleSort(int[] arr) {
//外循环控制循环次数
for (int i = 0; i < arr.length-1; i++) {
//i 0 1 2 3
//内层循环控制参与比较的元素
//j < arr.length-1-i 每次比较的次数
//防止了重复比较
for (int j = 0; j < arr.length-1-i; j++) {
//arr[j] arr[j+1]
if(arr[j]>arr[j+1]){
//两个元素交换 第三方变量
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
public static void printArr(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
System.out.print(arr[i]+"]");
}else{
System.out.print(arr[i]+",");
}
}
System.out.println();
}
}
二分查找，大大提高了查找效率：
代码实现：
package cn.itcast.ArraysTool;
/*
* 基本查找:
* 查找该元素在我的数组中的索引index
* 基本查找还可以查无序的数组
* 从索引0开始遍历一个个查找
*
* 有序这样做效率高不高?
*
* 二分查找(折半查找)
*
*/
public class ArraysDemo2 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7,8,9,10};
//查找6 的位置
// int index = searchIndex(arr,6);
// System.out.println(index);
//二分查找
// int index = halfSearch(arr,10);
//
// System.out.println(index);
//
// System.out.println(halfSearch(arr,100));
//你要查找的数组必须是有序的,升序
int[] arr1 = {11,23,34,46,58,69,79,82,93,1044};
System.out.println(halfSearch(arr1,82));
}
//二分查找
public static int halfSearch(int[] arr, int key) {
int min = 0;
int max = arr.length-1;
int mid = (min+max)/2;
//int mid = (min+max) >>> 1;
while(arr[mid]!=key){
if (key>arr[mid]) {
//更新最小的索引
min = mid +1;
} else {
//更新最大索引
max = mid-1;
}
if(min>max){
return -1;
}
mid = (min+max)/2;
}
return mid;
}
public static int searchIndex(int[] arr, int key) {
int index = -1;
for(int i = 0;i<arr.length;i++){
if(arr[i]==key){
index = i;
return index;
}
}
return index;
}
}
现在，有一个数组工具类，直接提供了方法
public static int binarySearch(int[] a,int key)
二分查找
public static void sort(int[] a)
性能调优的快速排序
升序
public static String toString(int[] a)
任意类型数组都可以按照字符串显示
Integer类
public static int binarySearch(int[] a,int key)
二分查找
public static void sort(int[] a)
性能调优的快速排序
升序
public static String toString(int[] a)
任意类型数组都可以按照字符串显示public static int binarySearch(int[] a,int key)
二分查找
public static void sort(int[] a)
性能调优的快速排序
升序
public static String toString(int[] a)
任意类型数组都可以按照字符串显示Arrays类概述
针对数组进行操作的工具类。
提供了排序，查找等功能。先了解一下基本类型的包装类：
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
基本类型和包装类的对应
Byte Short Integer Long Float Double Character Boolean
分别对应byte short int long float double char boolean
Integer 类在对象中包装了一个基本类型 int 的值,该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
还提供了处理 int 类型时非常有用的其他一些常量和方法
构造方法：
public Integer(int value) 将int类型转换为包装类
pub
df0c
lic Integer(String s) 将String类型的数字转换为包装类
成员方法：
A:常用的基本进制转换
public static String toBinaryString(int i)
public static String toOctalString(int i)
public static String toHexString(int i)
B:十进制到其他进制
public static String toString(int i,int radix) radie指的是哪个进制
C:其他进制到十进制
public static int parseInt(String s,int radix)
jDK5新特性：自动拆箱和自动装箱：
A:JDK5的新特性
自动装箱：把基本类型转换为包装类类型
自动拆箱：把包装类类型转换为基本类型
B:案例演示
JDK5的新特性自动装箱和拆箱
Integer i = new Integer(100);可以直接写成
Integer i = 100;//自动装箱
i=i+ 50;//自动拆箱,实际是一个intValue()
C:注意事项
在使用时，Integer x = null;代码就会出现NullPointerException。
建议先判断是否为null，然后再使用。
package cn.itcast_200;
public class Test {
public static void main(String[] args) {
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
// System.out.println(i1 == i2);
// System.out.println(i1.equals(i2));
// System.out.println("-----------");
//
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
// System.out.println(i3 == i4);
// System.out.println(i3.equals(i4));
// System.out.println("-----------");
//
// //Integer.valueof(127)
//
Integer i5 = 128;
Integer i6 = 128;
// System.out.println(i5 == i6);
// System.out.println(i5.equals(i6));
// System.out.println("-----------");
//
Integer i7 = 127;
Integer i8 = 127;
System.out.println(i7 == i8);
System.out.println(i7.equals(i8));
}
}
正则表达式
正则表达式
是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。
其实就是一种规则。有自己特殊的应用。
正则表达式的组成规则：
A:字符
x 字符 x。 举例： "a"表示字符a
\\ 反斜线字符。 "\\" -->需要匹配的内容是\ 两个\\表示一个\
\n 新行（换行）符 "\n" 换行符
\r 回车符 "\r" 回车符
B:字符类
[abc] a、b 或 c（简单类） "[abc]"需要匹配的内容得是字符a或b或c 的一个
[^abc] 任何字符，除了 a、b 或 c（否定） "[^abc]" 除了字符a或b或c的任意一个字符
[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围） "[a-zA-Z] "表示规则是一个字符规则可以是所有字母.
[a-zA-Z_0-9] 表示匹配的时候呢,数字,字母还有下划线都可以 ------单词字符
[0-9] 0到9的字符都包括 "[0-9]"表示匹配0~9之间的数字包括0,9
C:预定义字符类
. 任何字符。我的就是.字符本身，怎么表示呢? \. "."
\d 数字：[0-9] "\\d"
\w 单词字符：[a-zA-Z_0-9] 表示匹配所有字母+数字+下划线
在正则表达式里面组成单词的东西必须有这些东西组成
D:边界匹配器
^ 行的开头 ^[abc][0-9]$ 需要匹配的内容从[abc]这个位置开始, 相当于左双引号
$ 行的结尾 需要匹配的内容从[0-9]这个位置结束, 相当于右双引号
\b 单词边界 \b[a-z]\b 代表字母a,或b,或c 左右两边需要的是非单词字符
就是不是单词字符的地方。
举例：hello world?haha;xixi
E:Greedy 数量词
X? X，一次或一次也没有 "a?" 需要匹配的内容是对应的一个字符a,或者没有
X* X，零次或多次 "a*" 需要匹配的内容是多个字符a或一个都没有
X+ X，一次或多次 "a+" 需要匹配的内容是多个字符a或一个a
X{n} X，恰好 n 次 "a{5}"需要匹配5次a字符 "a"--恰巧一次 "a{1}"
X{n,} X，至少 n 次 "a{5,}"最少5次,不设置上限
X{n,m} X，至少 n 次，但是不超过 m 次 "a{5,8}"最少5次,最多8次
正则表达式的分割功能
String类的功能：public String[] split(String regex)
正则表达式的替换功能
String类的功能：public String replaceAll(String regex,String replacement)
把对应的该字符串中满足正则表达式部分的数据内容使用给定的新字符串所替换
返回的是替换后的新字符串
pattern模式的案例：
package cn.itcast_regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*
* Pattern:模式
* public static Pattern compile(String regex)
* 将给定的正则表达式编译到模式中。
* public Matcher matcher(CharSequence input)
* 创建匹配给定输入与此模式的匹配器。
* Matcher: 匹配器
*
*
*
*/
public class RegexDemo4 {
public static void main(String[] args) {
//"a*b"是一个正则表达式
Pattern p = Pattern.compile("a*b");//
//使用正则表达式对象启动匹配器,还把你要比较的数据放到匹配器中了
Matcher m = p.matcher("aaaaab");
//进行判断
boolean b = m.matches();//拿录入的数据与正则表达式进行匹配
System.out.println(b);
//用String 功能
String str ="aaaaab";
String regex ="a*b";
boolean b2 = str.matches(regex);
System.out.println(b2);
}
}
正则表达式的获取功能：
package cn.itcast_regextest;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*
* A:正则表达式的获取功能
Pattern和Matcher的结合使用
B:案例演示
需求：获取下面这个字符串中由三个字符组成的单词
da jia ting wo shuo,jin tian yao xia yu,bu
shang wan zi xi,gao xing bu?
Matcher:
public boolean find()
public String group()返回由以前匹配操作所匹配的输入子序列。
*/
public class RegexTest4 {
public static void main(String[] args) {
//定义字符串
String str = "da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?";
//定义规则
String regex = "\\b[a-zA-Z]{3}\\b";
//使用规则,获取满足条件的字符串
//把正则表达式编译成Pattern对象
Pattern p = Pattern.compile(regex);
//获取匹配器
Matcher m = p.matcher(str);
//判断我的str中有没有符合规则的字符单词
while(m.find()){
System.out.println(m.group());
}
}
}
Math类
math的中文翻译是数学，所以这个类全部都是有关于数学运算的
A:Math类概述
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
B:成员方法
public static int abs(int a) 返回一个数的绝对值
public static double ceil(double a) 返回的是比当前小数大的最小整数(用double表示的)
public static double floor(double a)返回的是比当前小数小的最大整数(用double表示的)
public static int max(int a,int b) min自学
public static double pow(double a,double b) a的b次方(用double)
public static double random()
public static int round(float a)
public static double sqrt(double a) 开方
Random类
A:Random类的概述
此类用于产生随机数如果用相同的种子创建两个 Random 实例，
则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
B:构造方法
public Random() 使用默认的种子用来创建随即数对象的空参构造方法,(默认种子就是当前时间毫秒值)
public Random(long seed):使用指定的种子来创建随机数对象,
C:成员方法
public int nextInt()返回一个随机的int范围内的整数
public int nextInt(int n) 0~指定范围内的,包括0不包括指定数
System 类
此类无法被实例化，但是包含三个成员方法
public static void exit(int status) 退出jvm
public static long currentTimeMillis() 获取当前时间
public static void gc() 垃圾回收器
BigInteger 类
可以让超过Integer范围内的数据进行运算!
构造方法：public BigInteger(String val)
public BigInteger add(BigInteger val) 加
public BigInteger subtract(BigInteger val) 减
public BigInteger multiply(BigInteger val) 乘
public BigInteger divide(BigInteger val) 除
public BigInteger[] divideAndRemainder(BigInteger val) 做了除法 用数组存放商和余数 第一个存商,第二个存余数
BigDecimal 类
由于在运算的时候，float类型和double很容易丢失精度，演示案例。所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal
构造方法
public BigDecimal(String val)
成员方法
public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor)
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)
案例演示：
package cn.itcast.BigDecimal;
import java.math.BigDecimal;
/*
* public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor)
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)
除完之后精确到小数点scale 位
BigDecimal.ROUND_HALF_UP 四舍五入
*/
public class BigDecimalDemo {
public static void main(String[] args) {
// System.out.println(0.09 + 0.01);//0.10 0.1
// System.out.println(1.0 - 0.32); //0.68
// System.out.println(1.015 * 100);//101.5
// System.out.println(1.301 / 100);//0.01301
BigDecimal bd1 = new BigDecimal("0.09");
BigDecimal bd2 = new BigDecimal("0.01");
System.out.println(bd1.add(bd2));
BigDecimal bd3 = new BigDecimal("1.0");
BigDecimal bd4 = new BigDecimal("0.32");
System.out.println(bd3.subtract(bd4));
BigDecimal bd5 = new BigDecimal("1.015");
BigDecimal bd6 = new BigDecimal("100");
System.out.println(bd5.multiply(bd6));
BigDecimal bd7 = new BigDecimal("1.991");
BigDecimal bd8 = new BigDecimal("100");
System.out.println(bd7.divide(bd8));
//1.301 100 2
System.out.println(bd7.divide(bd8, 2, BigDecimal.ROUND_HALF_UP));
}
}
Date类
A:Date类的概述
类 Date 表示特定的瞬间，精确到毫秒。
B:构造方法
public Date()
public Date(long date)
C:成员方法
public long getTime() //获取当前时间，long值
public void setTime(long time) 设置时间
SimpleDateFormat类
A:DateFormat类的概述
DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。
是抽象类，所以使用其子类SimpleDateFormat
B:SimpleDateFormat构造方法
public SimpleDateFormat()
public SimpleDateFormat(String pattern)
C:成员方法
public final String format(Date date)
public Date parse(String source) 配套使用
案例：
package cn.itcast.SimpleDateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
* DateFormat类的概述
DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。
是抽象类，所以使用其子类SimpleDateFormat
B:SimpleDateFormat构造方法
public SimpleDateFormat()
public SimpleDateFormat(String pattern)
c: public final String format(Date date)
public Date parse(String source)
"2015年11月11日 11:11:11"
y 年
M 月
d 日
H 时
m 分
s 秒
*/
public class SimpleDateFormatDemo {
public static void main(String[] args) throws ParseException {
//以下代码将日期变成了字符串的展示格式
//Date---->String
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat();
//对日期做格式化
String format = sdf.format(d);
System.out.println(format);
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(sdf2.format(d));
//String ----Date
String time = "2015-11-11 11:11:11";
Date parse = sdf2.parse(time);
System.out.println(parse);
}
}
Calendar类
Calendar类的概述
Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR
等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
成员方法
public static Calendar getInstance() 获取到一个日历类对象
public int get(int field)获取对应的日历字段
总结：
以上就是Api的一些知识，主要类笔记从详，了解类笔记从简。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 栈和队列的区别是啥? 吃多了拉就是队列;吃多了吐就是栈（程序员段子）
- 远古程序员
- 黑马程序员—Java基础—面向对象
- 黑马程序员—Java基础知识汇总
- 黑马程序员——javaSE_IO流
- 黑马程序员——javaSE_集合框架-Map
- 黑马程序员_java用java进行复制文件(考虑使用多线程),能系统自带快吗？？
- 从支付宝面试题谈：怎样有效减少用户咨询的客服成本
- 成为一名更好的程序员：如何阅读源代码
- 程序员能力矩阵翻译
- 黑马程序员——java基础语法
- 英语单词--程序员专属
- iOS进阶面试题
- 转 面试（马士兵聊）
- [转载] 面试的问题集
- 《程序员面试宝典》—上海某大学校招试题（第三章）
- IT职场人，切不要一辈子靠技术生存(转载）
- 读《VBScript程序员参考手册》，做的笔记
- 黑马程序员--匿名内部类问题
- 黑马程序员--面向对象(day07)