目录
boolean equals(object obj) 比较字符串对象中内容是否相等
boolean equalsIgnoreCase(string str)
boolean startsWith(string prefix)
boolean endsWith(string suffix)
int index0f(string str,int fromIndex)
String substring(int start,int end)
static string value0f(char[] chs)
String replace(char old,char new)
String replace(string old,string new）
replaceAll(String regex,string replacement)
replaceFirst(string regex,String replacement)
public StringBuffer append(String str)
public StringBuffer insert(int offset,String str)
public StringBuffer deleteCharAt(int index)
public StringBuffer delete(int start,int end)
public StringBuffer replace(int start,int end,String str)
long round(double a) double型的数据a转换为long型（四舍五入）
c1.get(Calendar. YEAR);//获得今年的年份
SimpleDateFormat(格式); // yyyy-MM-dd
BigInteger(String val) /BigInteger(byte[] val)
add()，subtract()，multiply()，divide()
add()，subtract()，multiply()，divide()
ListIterator迭代器，只能对List接口下的实现类遍历
swap（List<？>list ，int i，int j）交换i和j
常用类
Object类
存放在java.lang.Object包中
它是java类体系结构中最顶层的类,所有的类都直接或间接的继承Object类
Object可以表示Java中任意的类
Object类中的方法
toString方法
把对象所在的类的地址和对象在内存中的哈希值返回(以16进制)。
可以在自己的类中对Object中的toString()进行重写,后面调用时,就调用我们自己类中的toString()。
equals方法
==比较等号两边是否相等
==用于基本类型比较时，比较多是变量值是否相等
==用于引用类型比较适，比较的是对象的地址是否相等
Object类中的equals默认笔记两个对象的地址是否相等
在其他类中，一般都重写了equals（）；把它改造为比较对象中的内容是否相等
Arrays类
用于操作数组的各种方法（如排序和搜索）
类的地址为java.util.Arrays
equals方法
比较两个数组对象中元素是否相等
而数组对象中的equals用来判断与另一个数组对象是否相等
sort方法
将指定的类型数组所有元素按照数字升序进行排序
作用于数组的所有元素 public static void sort(type[] a)
binarySearch方法（二分查找）
使用二分搜索算法搜索指定数组
public static int binarySearch(type[] a, type key)
public static int binarySearch(long[] a,int fromIndex,int toIndex,long key)
查找的数组必须有序,可在查找前使用sort对数组进行排序
若返回负数则此元素不存在,存在则返回该元素的索引
参数： a - 要搜索的数组。 key - 要搜索的值。 fromIndex - 要排序的第一个元素的索引（包括）。 toIndex - 要排序的最后一个元素的索引（不包括）
如果一个类要进行排序,那么这个类必须实现compareable接口,指定一个排序的方法(这一所有的类都使用同一点方法进行排序)
compareaTo方法
用来指定排序规则
可以执行用类中那个属性作为排序的项
这个方法在sort()方法的底层调用,来排序大小
1.返回参与比较的前后两个字符串的ascii码的差值，如果两个字符串首字母不同，则该方法返回首字母的ascii码的差值
String a1 = "a";
String a2 = "c";
System.out.println(a1.compareTo(a2));//结果为-2
Comparable接口中的compareTo
compareTo方法内必须做非空判断（规范问题），当然int类型就不用了。
注意事项：
1、模型必须实现Comparable接口
2、Collection.sort(list)会自动调用compareTo,如果没有这句，list是不会排序的，也不会调用compareTo方法
3、如果是数组则用Arrays.sort(a)方法
public int compareTo(Book o) {
// TODO Auto-generated method stub
//return this.bookPrice-o.bookPrice;//按价格排序 升序
//return o.bookPrice-this.bookPrice;//按价格排序 降序
//return this.bookName.compareTo(o.bookName);//按书名排序 升序
//先按 id 再按价格 最后按书名排序 升序
int result = this.bookId - o.bookId;
if(result == 0){
result =this.bookPrice - o.bookPrice;
}
if(result == 0){
result = this.bookName.compareTo(o.bookName);
}
return result;
}
copyOf方法
copyOf（数组复制方法）可以用于创建一个新数组，复制旧数组中的内容并且可以设置新数组的长度
fill方法
用指定值将指定数组中的每个元素填充
fill(int[] a, int val)
toString方法
返回指定数组内容的字符串表示形式
基本类型包装类
java中的基本数据类型是使用8个关键字声明的,不是面向对象的
java语言是面向对象的,可以为每个基本类型定义一个类来进行表示
这样我们在类中还是保持有一个基本类型的变量存储数据,
同时还可以提供许多的方法对变量进行操作(例如将十进制转为二进制)
类型转换的方法
//转换的方法
//包装类型 转换为基本类型
int aa = a.intValue();//自动拆箱:把引用类型转为基本类型
int c = a;//自动拆箱:把引用类型转为基本类型
int bb = Integer.parseInt(20);
//吧基本类型 转换为包装类型
int cc = 10;
Integer dd = new Integer(cc);
Integer ee = Integer.value0f(cc);
自动装箱
把基本类型转为引用类型
int x = 10;
Integer yy = Integer.valueOf(x);
Integer y = x;
自动装箱时,.会默认调用valueOf();方法
在valueOf()中如果基本类型值在-128-127之间,会从缓存数组中直接取出一个Integer对象,减少创建次数,如果两个值相同,获取的是同一个对象
基本类型值如果不在这个区间,每次都创建一个新的Integer对象返回
int x= 1000;
//Integer yy = Integer.value0f(x);
Integer y=x;//自动装箱 会默认自动调用value0f()方法
Integer z=x;
System.out.println(y==z);// x=10 true x=128 false
//system.out.printin(y.equals(z));//true
String类
字符串是由多个字符组成的一串数据(字符序列)的字符串常量,java中所有字符串都是String类的实例.
java中字符串都是java.lang.String类的实例,String的底层是一个char数组
字符串对象创建方式:
1.String s = "abc";
创建时,先去字符串常量池中去查找有没有同值的对象,如果没有.就创建一个字符串对象,并返回地址,如果字符串中`已经储存,不用创建新的,直接返回已存在对象的地址
2.String s1 = new String("abc");
new每次都创建新的字符串变量
字符串不变:它们的值在创建后不能被更改
String s="abcd";// abcd
s+="efg";//abcdefg
s+="aaaa";//abcdefgaaaa
System.out.println(s);
每次都指向另一段字符串,最后输出的是最后定义的s
String类的方法
构造方法
String();
String(String a);
String(byte[] bytes);把字节数组 转为字符串
==s3.getBytes(); 把字符申转为字节数组==
String(char[] chars);把字符数组 转为字符串
==s4.toCharArray();把字符串转为字符数组==
String s3 ="你好";
byte[]bytes=s3.getBytes();//编码 把字符转为 字节数组
System.out.println(Arrays.tostring(bytes));
String s4 = new string(bytes);//解码 把字节数组转五字符
System.out.println(s4);
判断功能
boolean equals(object obj) 比较字符串对象中内容是否相等
String sl = new string( "abcd");
String s2 = new string( "abcd");
System.out.println(s1.equals(s2))
//此时结果为true
String sl = new string( "abcd");
String s2 = new string( "abcD");
System.out.println(s1.equals(s2))
//此时结果为false
boolean equalsIgnoreCase(string str)
忽略大小写进行比较
String sl = new string( "abcd");
String s2 = new string( "abcD");
System.out.println(s1.equals(s2))
//此时结果为true,忽略了大小写
boolean contains(string str)
//判断字符串中是否包含指定的子串
String sl = new string( "abcd");
System.out.println(s1.contains("ab"));
//结果为true
boolean isEmpty()
判断字符串值是否为" "(空)
boolean startsWith(string prefix)
判断字符串是否以指定的字符串开头
boolean endsWith(string suffix)
判断字符串是否以指定的字符串结尾
获取功能
int length()
获取字符串长度char
charAt(int index)
返回值为char 获取指定位置上的字符
String s1 = "abcdefg"
System.out.println(s1.charAt(4));
//输出的是e
for(int i=0;i<s1.length();i++){
System.out.println(s1.charAt(i))
int indexof(string str)
返回的是指定字符串首次出现的位置
String s1 = "abcdefg"
System.out,println(s1.indexOf("c"));
//输出的结果为2,数组的第三位
int index0f(string str,int fromIndex)
从指定的位置开始查找
int lastIndexOf("c")
从后向前找,返回指定字符串首次出现的位置
String substring(int start)
从指定的位置开始截取一个字符串副本,到结束
String substring(int start,int end)
从指定的位置开始截取到指定的位置,不包含结束的位置
转换功能
byte[ ] getBytes()
将字符串转为byte数组
char[ ]toCharArray()
将字符串转为字符数组
static string value0f(char[] chs)
将传入的参数转为字符串类型
String s= string.value0f(1000);//将int类型变为s字符串
System.out.println(s.charAt(1));//0
int a = Integer.parseInt(s);//将s字符串变为int类型
String sl= string.value0f("abc".tocharArray());//将abc变为char数组然后变为s1字符串
System.out.println(s1);//abc字符串
String toLowerCase();
将输入的字符串中的字母全部变为小写输出一个新的副本
String toUpperCase();
将输入的字符串中的字母全部变为大写输出一个新的副本
String concat(string str);
拼接指定字符串内容到原字符串末尾 返回一个新的字符串对象
Stirng[] split(分割符);
将一个字符串用指定的分割符拆分为一个字符串数组
String s2 = "ab,cd,ef"
String [] strings = s2.split(";");
System.out.println(Arrays.toString(strings));
//输出为[ab;cd;ef]
替换功能
String replace(char old,char new)
用新的字符替换字符串中指定字符
String s = "abcedfg";
System.out.println(s.replace(c,C));//输出abCedfg
String replace(string old,string new）
用新内容替换字符串中指定的字符串
replaceAll(String regex,string replacement)
用新内容替换字符串中正则表达式匹配的字符串
String s = "ab2ced3fg5";
System.out.println(s.replaceAll( regex:\\d,replacement: "C"));
//将所有的数字替换为C
replaceFirst(string regex,String replacement)
用新内容替换字符串中正则表达式匹配的第一个字符串
String s = "ab2ced3fg5";
System.out.println(s.replaceFirst( regex: "\\d", replacement: "c"));
//输出为abCced3fg5,替换了第一个被正则表达式匹配的字符
去除字符串两空格string trim()
StringBuffer类
为什么指定StringBuffer字符串？
因为String字符串声明的字符串对象值一旦给定就不能改变了
每次拼接都会创建新的字符串对象，耗时且占空间
而StringBuffer创建的是内容可以改变的字符串，底层是用一个数组来储存数据的，没有使用final修饰，每一次添加内容都是对此数组进行操作，不会创建新的字符串对象
我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。
而StringBuffer就可以解决这个问题
线程安全的可变字符序列
添加方法
public StringBuffer append(String str)
向字符串末尾添加字符串内容
public StringBuffer insert(int offset,String str)
向指定位置插入指定的字符串
public substring
String s2=s1.substring(0,5);
//截取字符串，从StringBuffer中截取一个字符串副本
//返回给一个新的String对象
删除功能
public StringBuffer deleteCharAt(int index)
删除指定位置的字符
public StringBuffer delete(int start,int end)
删除指定区间的字符串内容，包含开始的位置不包含结尾
替换功能
public StringBuffer replace(int start,int end,String str)
用新的字符串替换原字符串指定区间内的字符串内容，不包含结尾索引
反转功能
public StringBuffer reverse()
将数组的内容逆序（反转字符串）
StringBuilder类
String和StringBuffer和StringBuilder的区别
正则表达式
正则表达式（Regular Expression）简称regex，是一种用于文本处理和搜索的强大工具，它允许用户创建一个模式，用于在字符串中匹配特定的字符串
[0-9][1-9][357][a-z][A-z0-9]*+{n}{n,}fn,m}
\d匹数字 \D匹配非数字
\W匹配数字字母下创线 \W非数字字母下创线
\s匹配空格字符 \S非空格字符
丨逻辑或
.匹配任意字符，使用时需要转义
[\\u4e00-\\u9fa5]匹配汉字
如果字符串与规则相匹配，放回true，否则返回false
String s ="1234"; //System.oUt.println(s.matches("[0-9]*"));[0-9]*允许出现0次或多次数字
//System.oUt.printin(s.matches("[0-9]+"));[0-9]+允许出现至少1次或多次数字
//System.out.println(s.matches(regex:"1[0-9]{3}"));允许第一位为1，后面3位为0-9的数字
//System.out.println(s.matches(regex:"[0-9]{n, }"))至少出现n次数字
//System.out.println(s.matches(regex:"[0-9]{n,m}"));至少n次，不超过m次
System.out.println(s.matches(regex:"\d{3,6}"));// \d =[0-9]反斜杠d和数字0-9含义相同 \D匹配任意非数字，与小d相反Math类
java.lang.Math提供了一系列静态方法用于科学计算；
其方法的参数和返回值类型一般为double型。
abs 绝对值
sqrt 平方根
pow(double a, double b) a的b次幂
max(double a, double b)
min(double a, double b)
random() 返回 0.0 到 1.0 的随机数
long round(double a) double型的数据a转换为long型（四舍五入）
floor向下取整，ceil向上取整，round四舍五入
Random类
Random类概述
此类用于产生随机数
构造方法
public Random()
成员方法
public int nextInt()
public int nextInt(int n)
//bound可以给定一个范围，0-bound，在给定范围内随机取值
Date类
使用Date类来代表系统时间
构造方法
Date d = new Date();
获取程序运行时刻的时间
Date d = new Date(long d);
getYear，getMonth，getDate等方法
方法上有删除线
有删除线的方法表示已弃用，但是可以正常使用，已有其他方法替代其作用
getTime（）
获取的是自1970.1.1 0：0：0至程序运行时刻的毫秒值
可以用程序运行结束时刻的毫秒值减去程序运行刚开始的毫秒值
Date date = new date();
Date date1 = new date();
System.out.println(date1.getTime()-date.getTime());
Date date2=new Date(1708843278948L);//将指定long类型的时间戳构造出一个时间对象
Calendar类
Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建 对象的过程对程序员来说是透明的，只需要使用getInstance方法创建 即可
Calendar c1 = Calendar.getInstance()；
c1.get(Calendar. YEAR);//获得今年的年份
c1.get(Calender.需要获得的日期)；//通过调用Calender中不同的时间常量的编号来获得所需的时间
SimpleDateFormat类
SimpleDateFormat，日期格式化类
构造方法
SimpleDateFormat(格式); // yyyy-MM-dd
日期转字符串
Date now=new Date();
myFmt.format(now);
字符串转日期
myFmt.parse(“2018-02-10”);
字符串日期格式与 指定格式必须一致
String s =“2018-03-15”;
new SimpleDateFormat(“yyyy-MM-dd”)
/
把字符串日期转为Date对象
*/
String s="2002-02-03";
SimpleDateFormat sdf = new SimpleDateFormat(pattern:"yyyy-MM-dd");
Datedate sdf.parse(s);
System.out.println(date.getYear()+1900);
04
/*
把日期对象转为指定格式的字符串
*/
Date date1 new Date();
SimpleDateFormat sdf1 new SimpleDateFormat(pattern:"yyyyMM dd HH:mm:ss");
String s1 sdf1.format(date1);
System.out.println(s1)
BigInteger类
int 的最大值为 2^31-1。若希望描述更大的整数数据时，使用Integer 数据类型就无法实现了，所以Java中提供了BigInteger 类
BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意 精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而 不会丢失任何信息。
构造方法
BigInteger(String val) /BigInteger(byte[] val)
基本运算方法
add()，subtract()，multiply()，divide()
BigDecimal类
在计算机中float 还是double都是浮点数，而计算机是二进制的，浮点数会失 去一定的精确度
根本原因是:十进制浮点值没有完全相同的二进制表示形式;十进制浮点值的二进 制表示形式不精确,只能无限接近于那个值
构造方法
BigDecimal(String val)
基本运算方法
add()，subtract()，multiply()，divide()
集合/容器
数组特点:
一组数据类型相同的元素集合
创建数组时,必须给定长度,而且一旦创建,长度不能改变
一旦数组装满元素,就需要创建一个新的数组把原来的元素复制过去
不方便;
判断是否装满,如果装满了,数组复制创建一个新的元素
如果我们从数组中间删除一个元素,或者添加一个元素,需要移动后面的元素
java中为了解决数据存储单一的情况,java中提供了许多不同结构的集合类,让我们可以根据不同的场景进行数据的存储和选择,集合中的长度都是可变的
提供了数组实现的集合,链表实现的集合,哈希结构,树结构
集合
单列集合
一次放进去一个值,或一个对象
Collection接口，定义了单列集合共有的方法
List：可以有重复元素
ArrayList：数组列表
数据采用数组方式储存
底层有一个数字，可以动态的拓展数组的长度，并提供一系列的方法操作
集合容器类中默认可以添加Object类型
但是一般还是习惯一个集合对象中保存同一种类型
泛型：可以在声明类型时，自定义参数类型
ArrayList
add（E e）默认是向末尾添加元素
add（0，“e”）向指定维持添加元素
remove（“d”），匹配删除第一个指定的元素，删除成功返回true，否则返回false
remove（1），删除指定位置的元素，删除成功并返回所删除的元素
get（1），获取指定位置的元素
indexOf，获取指定元素第一次出现的位置，lastindexOf，从最后一位开始获取指定元素第一次出现的位置
set（1，“x”），替换并返回指定位置上的元素
isEmpty，判断集合中的元素是否为空
clear，清空集合中所有的元素
contains("c")判断是否包含指定的元素
size()返回集合中元素的个数
LinkedList：链表列表
底层是一个链表类，查询速度慢
add（“d”）向链表的末尾添加元素
add（1，“d”）向链表指定的位置插入元素
get（1）获取指定位置的元素
remove(“d”)删除指定的元素
remove(1)删除指定位置的元素
remove()删除并返回第一个元素
removeFirst()删除并返回第一个元素
addFirst（）从头开始添加元素
removeLast(),addLast()队列 先进先出 栈 后进后出Vector：数组列表 线程安全
List接口集合迭代
for循环遍历
for (int i=0;i<arrayList.size();i++){
System.out.println(arrayList.get(i));
}
允许对元素进行修改，但要注意修改完后元素的索引会改变，导致所修改的判断位置产生偏移
增强for循环的遍历
for (String s:arrayList){
System.out.println(s);
}
}
不能在遍历的时候修改集合元素（删除，添加）
迭代器遍历（Iterator）
Iterator<String> it = arrayList.iterator();
while (it.hasNext()){
String s = it.next();
if(s.equals("a")){
it.remove();
}
}
通过迭代器可以实现遍历数组并删除指定的元素
ListIterator迭代器，只能对List接口下的实现类遍历
可以实现从后向前遍历
Set接口：
Set接口继承了Collection接口，Set中存储的元素不能有重复元素，Set中的元素是无索引的
HashSet
HashSet类中的元素不能重复，且元素是无序的，通过HashCode和equals方法判断元素是否重复
HashSet<String> set = new HashSet<>();
set.add("2");
set.add("5");
set.add("333");
set.add("66");
set.add("1");
System.out.println(set);
//输出结果为[66, 1, 2, 333, 5]
HashSet在添加元素时是如何判断元素重复的：
当我们向集合中添加一个元素时，如歌每次都使用equals（）比较内容是否相等效率会很低
所以HashSet中在底层会调用hashCode（）--Object中的hashCode（）返回的是对象的地址（不调用这个），会调用类中重写的hashCode（），返回的是根据内容计算的哈希值
遍历时会用哈希值先比较是否相等，会提高比较的效率
但是哈希值会存在问题，出现内容不同哈希值相同的情况，此种情况下再调用equals方法来判断内容是否相等，
TreeSet
可以给Set集合中的元素进行指定方式的排序(有序)，存储的对象必须实现Comparable接口
TreeSet<Integer>treeSet = new TreeSet<Integer>();
treeSet.add(1);
treeSet.add(5);
treeSet.add(3);
treeSet.add(1);
//储存结果为1，3，5,没有重复元素1，经过了排序
底层使用了树形结构，树结构本身就是有序的
向treeset中添加的元素类型必须实现compareable接口，重写compareTo方法，每一次添加元素时，调用compareTo方法来进行元素大小的判断（<0放左子节点，=0表示重复，>0放在右子节点）
双列集合
键值映射
Map（Mapping）
数据存储是键：值的形式储存
键不能重复，值可以重复
通过键可以找到值
一个键只能映射到一个值
HashMap
键是无序的
map中添加的键如果重复则替换之前的键
HashMap底层存储数据结构
哈希表（数组），链表，树（红黑树）
第一步：用key计算哈希值，
1，数组主要用于定位 key--计算出一个int的哈希值 hash%数组长度（hash数组的默认长度是16），将元素放在哈希表中指定的位置
2，继续添加元素时，如果出现相同位置且不重复的元素，那么将后来的元素添加到之前元素的next节点位置
3，当链表的长度>=8时，且哈希数组长度>=64，链表会自动转为红黑树
4，哈希表负载因子为0.75，当哈希表使用数组的0.75时，会自动扩容为原来数组长度的2倍
TreeMap
底层使用树形结构存储键值 TreeMap 键可以排序 键元素的类型必须实现comaprable接口,重写compareTo方法
TreeMap<Integer, String> treeMap = new TreeMap<>();
treeMap.put(2,"aa");
treeMap.put(3,"baa");
treeMap.put(5,"caaa");
treeMap.put(4,"daaaa");
treeMap.put(6,"eaaaaa");
System.out.println(treeMap);
Hashtable
底层实现也是用到key的哈希值，计算位置，判断元素是否重复
方法上都添加了synchronized锁
Hashtable中不能储存为null的键和为null的锁，null无法调用Hashcode方法
HashMap可以储存一个为null的键，值可以为null
Map集合遍历
方式1：先拿到所有的键，再遍历键，根据键找值
map.keySet（）拿到所有的键
Set<String> keyset = treeMap.keySet();
for (String key:keyset){
System.out.println(key+":"+treeMap.get(key));
方式2：
Set<Map.Entry<String,String>> entries = treeMap.entrySet();
for (Map.Entry entry:entries){
System.out.println(entry.getKey()+":"+entry.getValue());
Collections类
addAll，将指定的可变长度参数数据添加到指定的集合中
addAll(Collection<? super T> c, T... elements)
int...a 可变长度的参数，本质是一个数组
一个参数列表中只能有一个可变长度参数，必须放在参数列表的最后
//自定义排序规则
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
Collections.sort(list, new Comparator<Integer>() {//创建了一个实现comparator接口的匿名内部类对象，省去创建一个类，简化语法
@Override
public int compare(Integer o1, Integer o2) {
return o1.intValue()-o2.intValue();//降序
}}
);
System.out.println(Collections.binarySearch(list,13));
//binarysearch二分查找法,在sort后进行查找，查找为升序
swap（List<？>list ，int i，int j）交换i和j
copy(list1,list);集合复制，将原集合复制到目标集合 要求目标集合size大于等于原集合的size
Colllections.shuffle(List<?> list)随机排序，将数组中的元素随机排序
reverse(list)逆序
6165
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
