Java第五周

1.常用类

1.常用类Object

哈希码值

int hashcode():（理解为地址值，不是实际地址值），支持散装列表（支持key--value键值对）

每一个对象的哈希码值都不一样

哈希算法：hash table

String toString()

返回对象的字符串表达形式，结果是描述成员信息表达式，建议所有子类重写

equals

boolean equals(Object obj)：比较两个数据（引用类型）是否相等

基本数据类型中==表示两个数据是否相等

==和equals区别

==比较两个基本类型，数据值是否相等

==连接两个引用类型，比较的是地址值是否相等

Object的equals方法，默认比较两个引用类型的地址值是否相等，建议子类需要重写equals，重写之后比较的是两个对象的成员信息是否相同（Java中所有的类都会重写），重写equals方法，必须同时重写hashCode方法

clone：克隆

0bject的克隆方法：

protected 0bject clone() throws CloneNotSupportedException创建对象并返回它的"副本" ​ 方法里面本身就会带有CloneNotSupportedException:克隆不支持的异常(当要对某个Object的类进行克隆如果这个类不能实现cloneable接口，那么就会出现这个异常)

要进行创建对象的副本，前提是这个类必须实现clonable接口，否则无法克隆

jdk中提供的接口里面什么都没有，叫做标记接口

clonable接口就是标记哪些类可以实现克隆

native本地方法，非Java语言实现

2.Scanner提供的一个判断功能

Scanner文本扫描器

hasNextXXX():判断录入的是否为XXX类型

hasNextLine():判断录入的下一个数据为一行内容

InputMismatchException输入类型不匹配

先录入int,在录入String ----nextLine() , 这块会出现被漏掉("回车符号") 解决方案: 1)在第一个录 入int之后,重新创建一个新的键盘录入对象Scanner ,然后在使用nextLine() 2)在录入String---- String next()

3.String以及StringBuffer(字符串缓冲区)

String是一个常量，不可变的字符序列，一旦被赋值，其值不可更改

String类final修饰不能被继承

字符串不变，它们的值在被创建后不能被改变（字符串是一个常量，存在常量池）

构造方法

public String():空字符串 类似String s="";

public String(String original):构造一个字符串对象，里面指定一个字符串常量

public String(byte[] bytes):使用平台默认字符集(idea默认utf-8)解析解码--->字节数组--->字符串String(byte[] bytes,int offset, int length) :将一部分字节数组构造成字符串

public String(char[ ] value):将字符数组---构造成String

public String(char[] value,int offset,int len):将一部分字符串数组构造成字符串

constant pool常量池

instanceof 判断是否是实例

数组中没有length()，字符串中没有length(),集合中有没有？

集合中没有，获取集合中元素数size()

String s=new String("hello")和String s="hello"有什么区别？

String类型的形参不影响实际参数

字符串一旦被赋值，就是常量

前者:在堆内存中开辟空间,然后字符串值常量---指向常量池，两个对象

后者:推荐的方式，直接常量赋值，直接在常量池中找，有就返回地址，没有,开辟常量空间!

String类相关的获取功能

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

2. int length获取字符串的长度

3. public String concat(String str)拼接功能，将一个字符串拼接到指定字符串的后面

4. public String substring(int beginIndex)截取，从指定位置开始，到末尾结束

5. public String substring(int beginIndex，int endIndex)截取，从指定位置开始，到指定位置结束，括号包前不包后

6. public String[] split(String regex)拆分，按照指定的分隔符将字符串拆分成字符串数组

7. public int indexOf(int ch)返回此字符第一次在字符串出现的位置

8. public int lastIndexOf(int ch)返回此字符最后一次在字符串出现的位置

append追加

String类型的转化功能

1.char[] toCharArray()将字符串转换成字符数组

String s = "helloworld" ;
正在
l/char[] toCharArray()将字符串转换成字符数组
char[] chs = s.toCharArray();//i'h' , ' e ' , 'l', 'l', ' o ' , ' w ' , ' o ' , ' r' , 'l', ' d'}/ /Arrays:数组工具类---toString(任意类型数组)--转换成String
String resultStr = Arrays.toString(chs);
system.out.println(resultStr) ;

2.byte[] getBytes()默认字符集编码和String (byte[] bytes)默认字符集解码

byte[] getBytes(String charset)指定字符集编码和String (byte[] bytes,String charset)指定字符集解码

编码和解码必须一致

1. String (byte[] bytes)将字节数组转换为字符串

2. String (byte[] bytes，int index,int length)从字节数组的某个位置开始，指定长度，转换为字符串

3.public String toLowerCase()将字符串转成小写

public String toUpperCase()将字符串转成大写

4.valueOf万能方法，任意数据类型转化为字符串

平台默认utf-8（一个中文对应三个字符）

需求:给定一个字符串，输入"Hellowold"，输出"hELLOWORLD"

1)可以录入字符串s1 2)将字符串的一个字符截取出来s2 substring(0, 1) -->"H" ----->转换小写toLowerCase() 3)s1字符串subString(1) ----> "ellowold"--->转换成大写 toupperCase()-->s3 4)2)和3)结果----->concat拼接功能----->结果s4 5)输出

String的判断/替换/比较/去除两端空格( 了解)相关功能

判断功能:

boolean contains (String str):判断大串中是否包含指定子字符串 boolean endsWith(String:suffix):判断是否以指定结尾的字符串 public boolean startsWith(String prefix): 判断是否指定的字符串开头 boolean equalsIgnoreCase (String anotherString) : 不区分大小写比较两个字符串是否相同 public boolean isEmpty(): 判断字符串是否空，长度为, true 空串,和空对象?一样吗?不一样

替换功能

public String replace(char oldChar, char newChar) : 替换功能 public String trim() : 去除字符串两端空格(一般io流中: 文件读写复制)

比较

public int compareTo两个字符串按照字典顺序比较 两个字符串进行字典顺序比较，先算出长度，取出最小值，然后比较每一个字符，如果这俩个字符串的第一个字符都不相同使用前面的字符和后面的的字符进行相减(ASII码表的值相减) 如果长度的最小值，在循环遍历两个字符串的每一个字符之前，都相同，直接是两个字符串长度相减!

+字符串拼接符号

concat(String str) +更高效

String s=null;

s.concat("hello");左边不能为空对象，如果为空会导致空指针

2.StringBuffer(字符串缓冲区，线程安全的类)/StringBuilder

StringBuffer：线程安全的类，支持可变字符序列

线程依赖于进程，执行的最小单元

线程安全意味着同步，执行效率低；反之，效率高

1）构造方法

public StringBuffer()空参构造，初始容量16个字符

public StringBuffer(int capacity)指定容量大小的字符串缓冲区

public StringBuffer(String str)指定字符串内容构造到字符串缓冲区，容量=当前str长度+16

int length获取缓冲区长度

int capacity获取容量大小

2）StringBuffer的追加

public StringBuffer append()：将指定的类型追加字符串到缓冲区的序列中,返回自己本身

class A{
    public static void main(String[] args){
        StringBuffer s=new StringBuffer();
        s.append(100).append("wer").append("LK")
            System.out.println(s)
    }
}

3）StringBuffer的插入

public StringBuffer insert(int index,String str)可以插入任意类型，在指定位置的前面插入指定数据，返回字符串缓冲区本身

4）StringBuffer的替换

public StringBuffer replace(int start,int end,String str)可以是任意类型将start位置到end-1位置的字符序列进行替换

5）StringBuffer的特有功能

public StringBuffer reverse()将字符串缓冲区的字符序列进行反转

6）StringBuffer删除

public char charAt(int index):获取字符串缓冲区中指定位置的字符，返回指定的字符

StringBuffer delete(int start，int end):删除从指定位置开始到指定位置结束(end-1)的字符,返回字符串缓冲区本身

StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回值字符串缓冲区本身

7）StringBuffer转为String

StringBuffer buffer = new StringBuffer("helloJavaEE") ;

方式1: stringBuffer的成员方法public string tostring ()

stringBuffer buffer = new stringBuffer ( "abc" ) ;

string s = buffer.tostring ( ) ; 方式2: string的构造方法String (StringBuffer sb) stringBuffer buffer2 = new stringBuffer ( "abc") ;

string s2 = new String (buffer2) ;

8）String转为StringBuffer

使用StringBuffer(String str)有参构造

String a="wer";

StringBuffer s=new StringBuffer(a)

使用StringBuffer()空参构造，结合append(String str)追加

9)String和StringBuffer/StringBuilder的区别

String是一个常量，其值不能被改，不可变的字符序列

作为形参，不改变实际参数（和基本类型一致）

StringBuffer支持可变字符序列，字符串缓冲区，线程安全的类,执行效率低，作为形参，影响实际参数

大部分功能 synchronzied:同步锁（悲观锁）

StringBuilder和StringBuffer具备相互兼容的API，线程不安全的类，执行效率高

单线程只考虑效率，使用StringBuilder

多线程使用StringBuilder

10)截取功能

substring(int beginIndex,int endIndex): 返回一个字符串，该字符串是此字符串的子字符串。 子串开始于指定beginIndex并延伸到字符索引endIndex - 1 。

3.java.util.Date日期/Random随机数/System/Calendar日历/Bigdecimal小数精确计算

1.java.util.Date特定的日期

1）构造方法：

public Date()：系统时间的日期格式

2）成员方法

public long getTime()∶获取指定Date对象的系统时间毫秒值

格式化或解析：使用DateFormat类，他是抽象类，不能实例化，用抽象类的子类SimpleDateFormat(String pattern)

partten模式：yyyy年MM月dd月

HH小时数mm分钟数ss秒数

3）Date日期String格式化

public final String format(Date date)

Date date = new Date() ;
/ /SimpleDateFormat(String pattern):转换器
SimpleDateFormat sdf = new SimpleDateFormat( pattern:"yyyy-MMN-dd HH:mm: ss") ;
String dateStr = sdf.format(date);
system.out.println(dateStr);

public static String date2String(Date date,String pattern){
    return new simpleDateFormat(pattern).format(date) ;
}

1)创建当前日期对象 Date date2 = new Date (o) ;

2)创建解析器对象 simpleDateFormat sdf2 = new simpleDateFormat ("yyyy-MM-dd") ;

3)格式化 string datestr =sdf2 .format (sdf2) ;

4）String日期转为Date

ParseException解析异常

如果String日期文本和转换器SimplelDateFormat(String pattern)里面的模式不匹配就会造成解析异常!

string s = "2022-11-16";

1)创建解析器 simpleDateFomart sdf = new simpleDateFormat ("yyyy-MM-dd") ;

2 ) Date date = sdf.parse (s) ;

public static Date string2Date(String source ,String pattern) throws ParseException {
    return new simpleDateFormat(pattern).parse(source) ;
}

5）获取当前系统时间毫秒值

newTime

system类的静态方法

public static long currentTimeMillis()

String日期文本---->解析java.util.Date日期对象

6）自定义一个工具类

构造私有化,外界不能new 定义一个两个静态方法 调用jdk提供的一个类的方法---- 如果这个方法本身throws异常类名, 我们必须处理! 异常处理方式

1) throws : 抛出
2)开发中捕获异常
try{
可能出现问题的代码
}catch(异常类名对象名){
对象名. printStackTrice();跟踪堆栈.
}

2.System

不能实例化

三个变量，静态常量

static PrintStream err“标准”错误输出流l static InputStream in"标准”输入流。(InputStream:字节输入流--读数据) static PrintStream out“标准"输出流。(PrintStream字节打印流--->QutputStream字节输出流---写/打氏

PrintStream ps=Systen.out返回字节打印流：是字节流的一种io流

成员方法

1. public static long currentTimeMillis()获取系统时间毫秒值

2. public static void exit(int status):参数为0，正常终止jvm

3. gc()手动启动垃圾回收器，开启垃圾回收器，会调用Object类的finalize()垃圾回收方法

4. static void arraycopy(原数组，元素组中的某个位置，目标数组，目标数组中的某个位置，从原数组的那个位置srcPos指定长度复制到目标数组中)

final和finalize，finally有什么区别？

final状态修饰符，表示最终的，无法更改的，修饰类，不能被继承；修饰成员方法，不能被重写；修饰变量，成为常量

finalize是一个方法，Object类的方法，主要垃圾回收器没有更多引用对象，来释放空间

finally关键字：捕获异常标准格式：

try{

可能出现问题的代码

}catch（异常类名变量名）{

处理异常

}finally{

释放系统资源

Io流(创建文件、流对象都需要关闭)/jdbc(连接对象，执行对象，查询对象都需要close())

}

3.Random

伪随机数生成器

构造方法

public Random()：创建新的随机数生成器

成员方法

int nextInt()获取int类型的取值范围

int nextInt(int n):[0，n)随机数

4.集合--支持可变长度

只能存储引用类型

5.Integer

jdk5以后的新特性

范围-128-127

自动拆装箱：装箱：基本类型--自动提升引用类型

拆箱：引用类型--自动降为基本类型

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

1）Integer构造方法

1. public Integer(int value) :将int类型数据包装为Integer类型

2. public Integer(String s)throws NumberFormatException :将字符串类型包装Integer类型，如果字符串非数字字符串,就会出现NumberFormatExceptio数字格式化异常

2）装箱

Integer i=new Integer(XX);

3）拆箱

public int intValue()

4）Integer a=10和Integer i=new Integer(10)的区别

Integer a=X(int型)；执行底层的Integer.valueOf()---IntegerCache静态成员内部类(内部缓存区)---Low(-128)/high(127),超过范围，new Integer();重新创建Integer类对象，开辟内存空间

5）类型转换

int---String

方式一：字符串拼接“+”

方式二：int---Integer---String

Integer i=new Integer(i);

String a=i.toString();

方式三：静态方法public static String toString(int i)

String i=Integer.toString(i);

String----int

方式一：String---Integer---public int intValue()

Integer i=new Integer(i);

int value=i.intValue()

方式二：静态方法public static int parseInt(String s)

String i=Integer.parseInt(i);

parseXXX：任意类型都可以

6）十进制转换为其他进制字符串形式

public static String toBinaryString(int i):将十进制--转换二进制的字符串形式

public static string toHexString(int i)将十进制--转换十六进制的字符串形式

public static String to0ctalstring(int i)将十进制--转换八进制的字符串形式*/

6.Character

1）构造方法

Character(char value)包装一个char类型

2）成员方法

public static boolean isDigit(char ch)判断是否为数字字符

System.out.println(Character.isDigit( ch: '0') );

public static boolean isUpperCase(char ch)判断是否为大写字符

System.out.println(Character.isUpperCase( ch: 'A') );

public static boolean isLowerCase(char ch)判断是否为小写字符

System.out.println(Character.isLowerCase( ch: 'a') );

7.Calendar日历类/BigDecimal小数精确计算

java.util.Calendar日历类是一个抽象类

如果这个类是一个抽象类，这个类里面的某些功能（静态功能）--一定完成了这个类的子类的实例

创建日历实例：getInstance（）

Calendar提供静态的字段(成员变量--->静态常量)

public static final int DATE:月中的日期值=DAY_OF_MONTH

public static final int MONTH:年中的月份值(0-11)必须要+1

public static final int YEAR:年份值

Calendar提供成员方法:

获取日历的字段值

public int get(int field)

参数就是需要通过Calender访问静态常量的那些字段

给日历字段设置偏移量

添加或减去amount值

public abstract void add(int field,int amount)

add（year，-5）5年前

设置日历字段

public final

BigDecimal小数精确计算

构造方法

BigDecimal ( String value):参数"小数字符串值"

BigDecimal ( int value):参数"小数字整型值"

BigDecimal ( double value):参数"小数值"

成员方法:

1. public BigDecimal add(BigDecimal augend):加

2. public BigDecimal subtract(BigDecimal subtrahend)减

3. public BigDecimal multiply(BigDecimal multiplicand)乘

4. public BigDecimal divide(BigDecimal divisor):除

5. public BigDecimal divide(BigDecimal divisor除数值 ,int scale保留小数位数,int roundingMode舍入的模式)

jdk5新特性

静态导入：导入到方法的级别

import static 包名.类名.方法名；

前提使用静态导入，这个类必须为静态

在使用静态导入的时候，导入jdk提供的的一些工具类里面静态方法的时候，我们定义的方法不能和他的方法名冲突；如果冲突，静态导入不识别，这个时候必须导入全限定名称包名.类名.方法名

可变参数

当一个方法形式参数不知道有多少个，这个时候使用可变参数（类似一个数组）

abs求绝对值

集合和数组的区别

1. 长度区别：数组长度固定的

   集合长度是可变的

2. 存储数据类型的区别：

   1. 数组：皆可以存储基本类型，也可以存储引用类型，但是这些数组的类型必须一致

   2. 集合：只能存储引用数据类型，如果集合不带泛型，那么本身就可以存储任意类型数据

3. 存储元素的区别：

   1. 数组：存储必须一种类型的元素

   2. 集合：存储任意引用类型

8.Collection

没有jdk提供直接实现，通过具体的子接口list，set的子类实现

创建集合的时候<E>：里面存储的引用数据类型的元素

模拟数组，创建集合的时候就明确了集合中存储的数据类型

1.Collection基本功能

添加add()

删除：删除指定的元素boolean remove(Object o)

暴力清空void clear()

判断：isEmpty()判断集合是否为空

contains(Object o)判断集合是否包含指定元素

2.Collection的遍历

将集合转为字符数组

Object[] toArray

使用collection存储自定义对象（学生对象--针对学生类，进行遍历）

public static void main (String[] args) {
//创建一个集合--->存储String
    collection<String> c = new ArrayList<>() ;/添加字符串数据
    c.add("hello") ;
    c.add( "world" ) ;
    c.add( "javaEE") ;
    c.add( "Mysql") ;
    system.out.println(c);
//转换成数组0bject[] toArray()0bject[] objects = c.toArray();
    for(int x =0 ; x < objects.length ;x++){
        //objects[x]数组中---相当于每一个元素 0bject对象名 = new String();
        //多态向上转型l / system . out.println(objects[x]);
        //遍历这些字符串并且同时它的长度
        // system.out.println(objects[x]+" ---"+objects[x].length()); 
        //Object类型没有length()/向下转型
        String s = (String) objects[x];
        system.out.println(s+" ---"+s.length());
​
    }
}
​

@SuppressWarnings(all)压制警告

Collection的专有遍历方式：迭代器

Iterator接口提供了功能：Object next() 获取下一个可以遍历的元素

boolean hasNext():判断如果迭代器里面有元素,则返回true,然后在获取!

并发修改异常

java.util.ConcurrentModificationException:

出现原因：当使用迭代器去遍历元素的时候，不能同时使用集合操作元素

解决：

使用迭代器遍历，迭代器添加，但是现在Collection的迭代器没有添加功能----List集合的特有列表迭代器ListIterator

使用集合遍历，集合添加，Collection没有直接通过角标获取元素的功能

List集合Eget(int index) for(int x= ;x < list集合对象.size() ;x++){ String s = list集合对象.get(x) ;

if("world" ). equals(s){ ​ list集合对象.add( "javaee " ) ;

} }

9.List集合

特点

允许集合元素重复，而且有序集合(存取顺序一致)

三个子实现类特点

ArrayList:底层数据结构是数组-----查询快，增删慢

从线程来说，线程不安全，不同步，执行效率高

不明确使用什么集合（单线程）时默认使用

LinkedList：底层数据结构是链表---查询慢，增删快

从线程来说，线程不安全，不同步，执行效率高

当如果要去删除最后一个元素/将每一个元素添加集合开头时使用

Vector：底层结构是数组---查询快，增删慢

从线程来说，线程安全，同步，执行效率低（多线程使用）

List集合的特有功能

在指定位置后面插入新的元素：add(int index,element)

获取指定位置处的元素：get(int index)

在指定位置替换（修改）指定元素：set(int index,element)

列表迭代器-List专有遍历：ListIterator

ListIterator--->正向列表遍历 :boolean hasNext() + E next():获取下一个元素

ListIterator<String> lit = list.listIterator();
while(lit.hasNext()){
    string s = lit.next() ;//lit.next()只能使用一次，不能使用多次
    system.out.println(s+" ---"+s.length());
}
​

逆序遍历必须有正向遍历hasPrevious()

list集合中所有元素遍历

1. list集合继承Collection----Object[] toArray()

2. Collection的迭代器Iterator iterator()

3. 列表迭代器ListIterator

4. List集合的get+size的普通for循环

it.next()只能使用一次，不能使用多次

增强for

jdk5新特性，是为了替代迭代器，简化代码书写程度

特点：前提条件：集合或数组对象不能为null

for(泛型里面存储的数据类型 变量名：集合或者数组名称){

使用变量名

}

list去重

List存储自定义类型,

1. 而使用新建集合思想去重,contains()底层依赖Obejct的equals

2. 而Object的equals方法默认比较是==,两个对象地址值是否一样

3. 存储自定义类型保证元素唯一,自定义类型重写equals方法()/hashCode(),成员信息是否一样,如果一样,还要比较成员的哈希码值是否一样,如果都一样,那么就是同一个人

排序的思想

使用0角标对应的元素依次和后面元素比较,如果后面元素和前面的元素重复,将后面的元素干掉,(集合中remove(元素))

10.Vector和LinkeList的特有功能

Vector

Vector集合:线程安全的类(底层结构:数组,查询快,增删慢)

特有功能:

1.public void addELement(E obj)将指定的元素添加Vector集合中(默认追加) 2.public Enumeration<E> eLements(): 获取枚举组件接口----->类似FCollection集合的Iterator iterator() Enumeration接口 3.boolean hasMoreELements() 判断是否有元素-----> 类似于Iterator里面的boolean hasNext() 4.nextELement():获取下一个元素---->类似于Iterator里面的E next 5.public E eLementAt(int index): 通过索引值获取元素 ---->类似List集合的E get(int index) 6.int size(): 获取集合元素数

特有遍历方式

特有遍历方式1 for(int X =0; x < v.size() ;X++){ String s = V. eLementAt(x) ; System. out. printLn(s); } //特有遍历方式2 Enumeration<String> en = v. eLements(); while (en. hasMoreELements()){ String S = en. nextELement() ; System. out . printLn(s); }

LinkedList

线程不安全,不同步,执行效率高 底层数据结构:线程结构之链表,查询慢,增删快!

特有功能:

1. public void addFirst(E e)将指定的元素添加到链表的开头

2. public void addLast(E e)将指定的元素添加到链表的末尾

3. public E getFirst(): 获取第一个元素

4. public E getLast(): 获取最后一个元素

5. public E removeFirst(): 删除并返回第一个元素

6. public E removeLast(): 删除最后一个元素并返回

11.Set集合:唯一/无序(不能保证迭代顺序)

引入

HashSet--->哈希表--依赖于HashMap TreeSet---->红黑树--依赖TreeMap (自然排序/比较器排序:依赖于使用的构造方法)

Set集合:元素唯一的 默认情况使用HashSet进行实例(创建对象) HashSet的底层依赖HashMap(哈希表结构),元素唯一 ,迭代顺序无法保证的!

元素唯一

HashSet集合保证元素唯一 ---底层依赖HashMap的put方法---->依赖FhashCode()/equals(), 存储String类型,需要重写equals hashCode(),保证元素唯一!

TreeSet集合

Set集合的的实现类,它应该满足保证元素唯一 底层基于TreeMap<K,V>,它是一个红黑树(red-black-tree) 自然排序/比较器排序

构造方法:

public TreeSet():创建一个空的树,元素是按照自然排序顺序,里面的元素必须要实现Comparable接口

注意

要实现自然排序,那么使用TreeSet的无参构造方法,而且存的类型一定要实现Comparable接口,重写compareTo(T t)方法,完成比较

TreeSet存储Integer类型的元素

要实现自然排序,那么使用TreeSet的无参构造方法,而且存的类型一定 要实现Comparable接口,重写compareTo(T t)方法，完成比较

使用TreeSet存储自定义类型

存储的Student类型实现Comparable,完成自然排序!

使用TreeSet<Student>,按照自然排序排序

红黑树

是一个自平衡的二叉树的结构

public TreeSet(): 创建一个空的树,元素是按照自然排序顺序,里面的元素必须要实现Comparable接口

自然排序(默认使用的这种:大部分常用String/Integer/Character 都实现Comparable)

TreeSet<自定义类型>,如果要实现自然排序,使用TreeSet的无参构造方法 public TreeSet<E>() 自定义类型必须实现一个接口:Comparable<T>--->实现public int compareTo(T t){排序规则...}

比较器排序

自定义类实现Comparator

TreeSet有参构造方法 public TreeSet(Comparator<? super E> comparator)

比较器排序方式1:

自定义一个类实现Comparator接口 MyComparator my = new MyComparator() ; //具体类对象 Comparator<Student> my = new MyComparator() ; //接口多态 TreeSet<Student> ts = new TreeSet<>(my) ;

方式2:

public TreeSet(Comparator<? super E> comparator) 按照比较强排序,使用接口匿名内部类

TreeSet<自定义类型> ts = new TreeSet<>(new Comparator<自定义类型>(){ public int compare(自定义类型 t1,自定义类型 t2){排序规则...}

}) ;

字典顺序比较的逻辑

String字符串里面的compareTo(String str)逻辑 "hello" "abc" "hell" 这个方法:将字符串---->字符数组---->获取两个字符串长度的最小值(临界点) int k = 0 ; while( k < 长度最小值){

不断两个字符数组每一个字符 如果第一个字符值不同,直接方法结束: 返回 两个字符相减 (ASCII码表的值)

k++

如果循环结束之前,如果者两个字符串的都相同,返回字符串长度 相减

}

注意

当你有String数据,有int数据录入,防止出现先录入int,在录入String,String数据漏掉 全部使用String,---需要int---使用Integer.parseInt(数字字符串);

12.Map集合

大集合

HashMap<String,ArrayList<String>>

现在使用单列集合Collection<E></>--->List /Set List<Student>,本身就是将整个对象存储进去了,获取方式直接获取学生数据,遍历---->判断 所以Java提供 Map<K,V> 键值对,一个键(必须唯一)对应一个值(值可以重复)

Map和Collection的区别?

Collection<E>:单例集合,只能存储一种引用类型数据 遍历方式和Map不同; Collection集合的应用范围大: ArrayList Vector LinkedList

它里面的部分集合和Map有关联(HashSet--->依赖HashMap / TreeSet----> 依赖TreeMap) Map<K, V>,双列集合---->可以存储键值对("夫妻对") 遍历方式:通用方式获取所有的键,通过键找值!

应用范围:

HashMap---->存储和获取(默认使用) TreeMap---->存储---获取(按照排序规则排序) Map-->称为"实体" Map<Integer,Product>

Map(针对键有效,键必须唯一)的基本功能

添加:

V put(K key, V value):添加键值对元素,返回值什么意思? map针对键有效,键如果唯一的， 返回是null， 如果重复，将后面的键对应的值把前面的值覆盖了,返回第一次键对应的值

删除:

V remove(0bject key): 删除键,返回键对应的值 void clear(): 暴力删除,将map清空掉

判断:

boolean containsKey(object key): 判断Map集合是否包含指定的键,包含返回true,否则false boolean containsValue(0bject vaLue): 判断Map集合是否包含指定的值,包含则返回true,否则false boolean isEmpty() : 判断集合是否为空

遍历Map集合的方式

1)获取所有的键的集合

Set<String> keySet = map.keySet() ; for(String key:keySet){ //通过键获取值 String value = map.get(key); System.out.println(key+"---"+value) ; }

2)Set<Map. Entry<K, V>> entrySet() :获取Map结合的键值对对象

Set<Map . Entry<String，String>> entry = map. entrySet() ; for (Map . Entry<String，String> en: entry){ String key = en. getKey(); String value = en. getValue() ; System. out. println(key+"---"+value) ;

注意

1.HashMap---->put方法---->依赖hashCode()+equals()方法 能够保证键唯一!存储String,String类型重写了hashCode()+equals()方法,比较键的字符串内容是否相同!

2.如果K是自定义类型,要针对键有效,需要键的类型,需要重写equals和hashCode() equals():比较内容是否相同，hashCode(): 比较每一个成员信息的哈希码值是否一样

TreeMap

构造方法:

• public TreeMap():自然排序

• public TreeMap(Comparator<? super K> comparator):比较器排序

• 如果键是自定义类型,键必须唯一,而且需要有排序规则!

13.Collections:针对集合的操作工具类

java. util. Collections:针对集合操作工具类

常用的方法

1. 二分搜索法,在指定List集合中查询指定元素第一次出现索引值 ( 集合的元素有序) public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)

2. public static <T> T max(Collection<? extends T> coll): 针对Collection集合获取最大值(自然顺序比较获取最大值)

3. public static <T> T min(Collection<? extends T> coll): 针对Collection集合获取最小值(自然顺序比较获取最小值)

4. public static void reverse(List<?> list):将List集合的元素反转

5. public static void shuffle(List<?> list): 针对List集合随机置换

6. pubLic static <T extends Comparable<? super T>> void sort(List<T> List):针对L ist集合按照自然顺序排序

7. public static <T extends Comparable<? super T>> void sort(List<T> List,Comparator<T> com):针对List集合按照比较器排序

14.使用集合模板斗地主洗牌和发牌

1)发牌--->发到每个人的手上的牌无序

斗地主:三个玩家----54张牌, 底牌3张 不考虑三个玩家的手上牌有序的! 分析: 1)牌盒------------>ArrayList<String> 2)装牌 点数数组= {"A", "2", "3....... "10", "J", "Q", "K"} 花色数组= {"♥","♠","♣","♦"} 将每一个点数和花色拼接(concat(String str) 到一块"牌" 将"牌"添加牌盒中 单独添加"小王", "大王” 3)洗牌-------->将ArrayList随机置换---Collections的 public static void shuffle(List<?> list针对List集合随机置换 4)发牌: 三个玩家---->看成三个集合,每一个玩家就尽ArrayL ist<String> 底牌--->也可以成集合 A--->B--->C 规律: 遍历ArrayList.集合,里面去判断 for(int X =0; x <牌盒集合.size();x++ ){ if(x%3==0){ //玩家1 add(大集合的集合. get(x)) }else if(x%3==1){ //玩家2 }else if(x%3==2){ ... } } 调用用看牌的方法("玩家1",玩家1的集合) ; 调用用看牌的方法("玩家2",玩家2的集合) ; 调用用看牌的方法("玩家了",玩家3的集合) ;

5)看牌 定义一个方法 public static void LoolPoker(String name , ArrayL ist<String> array){ //xxx的牌是 将牌全部遍历出来,展示信息 }

public class PokerDemo {
    public static void main(String[] args) {
        ArrayList<String> pokerBox  = new ArrayList<>() ;
        String[] numbers = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"} ;
        String[] colors = {"♥","♠","♣","♦"} ;
        for(String color:colors){
            for(String number:numbers){
                String poker = color.concat(number);
                //添加pokerBox中
                pokerBox.add(poker) ;
            }
        }
        pokerBox.add("小王") ;
        pokerBox.add("大王") ;
        System.out.println(pokerBox) ;
        Collections.shuffle(pokerBox) ;
        System.out.println(pokerBox);
        ArrayList<String> player1 = new ArrayList<>() ;
        ArrayList<String> player2 = new ArrayList<>() ;
        ArrayList<String> player3 = new ArrayList<>() ;
        ArrayList<String> diPai = new ArrayList<>() ;
        for(int x = 0 ; x < pokerBox.size()  ;x++){
            if(x>= pokerBox.size()-3){
                diPai.add(pokerBox.get(x)) ;
            }else if(x%3==0){
                player1.add(pokerBox.get(x)) ;
            }else if(x%3==1){
                player2.add(pokerBox.get(x)) ;
            }else {
                player3.add(pokerBox.get(x)) ;
            }
        }
        lookPoker("高圆圆",player1) ;
        lookPoker("张杨",player2) ;
        lookPoker("赵又廷",player3) ;
        lookPoker("底牌",diPai) ;
    }
    public static void lookPoker(String name,ArrayList<String> array){
        System.out.print(name+"的牌是:\t" ) ;
        //遍历牌(ArrayList)
        for(String s:array){
            System.out.print(s+" ") ;
        }
        System.out.println();
    }
}

15.线程和进程

jvm是多线程

进程:

能够调用系统资源的独立单位!(打开任务管理器,查看进程状态)

多进程:

计算机都是支持多进程,提高CPU的使用率! 开启多个进程的时候,玩游戏的同时可以听音乐,他们并不是同时进行的,而是一点时间片在两个进程之间进行高效切换!

线程:

能够执行的最小单元!(一个线程可以看成进程的某个任务) 360软件---->开启---->开启进程 同时清理内存---同时查杀病毒

多线程的意义:

多个线程在互相抢占CPU执行权,线程的执行具有随机性!

jvm是多线程吗?

是一个多线程的,至少有两条线程 开启main线程---用户线程 gc----垃圾回收器 开启垃圾回收线程(回收没有更多的对象)

Java能够直接创建多线程吗?

创建线程---->需要创建进程---->需要使用系统资源创建进程 Java是不能够直接操作系统资源的,底层语記C是可以操作系统的 Jdk提供了Thread类,里面有个start()---->执行线程---底层非Java语言实现的

提供Thread类第一种创建线程的方式 1)自定义一个类继承的自Thread类 2)重写Thread类的run方法---->完成一些的耗时的操作 3)在main用户线程中,创建当前这个类对象 4)开启线程---->不是run方法,run方法它只是一个普通方法(仅仅执行线程里面的内容:读文件/完成io的操作...) 启动线程start()--->jvm是调用run线程的方法，结果是两个同时执行(具有随机性)

java. lang. IllegalThreadStateException非法线 程状态异常(一个线程不能启动多次)

Thread类提供一些基本功能:

public final void setName(String name):设置线程的名称 public final String getName():获取线程名称

优先级

public static final int MAX_PRIORITY 10最大优先级 public static final int MIN_PRIORITY 1最小优先级 public static final int NORM_ ,PRIORITY 5默认 优先级 优先级越大,线程抢占CPU执行权的几率越大!

给线程设置优先级

public final void setPriority(int newPriority)获取线程的优先级 public final int getPriority()

Java创建多线程方式

1)继承关系 Java提供的Thread类 2)实现关系 Runnable接口(方式2:使用Java设计模式之静态代理--设计模式之结构型设计模型的一种代理类/和被代理类都需要实现同一个接口)

线程的有几种状态

生命周期:就是线程从新建--->就绪--->执

1.常用类

1.常用类Object

哈希码值

int hashcode():（理解为地址值，不是实际地址值），支持散装列表（支持key--value键值对）

每一个对象的哈希码值都不一样

哈希算法：hash table

String toString()

返回对象的字符串表达形式，结果是描述成员信息表达式，建议所有子类重写

equals

boolean equals(Object obj)：比较两个数据（引用类型）是否相等

基本数据类型中==表示两个数据是否相等

==和equals区别

==比较两个基本类型，数据值是否相等

==连接两个引用类型，比较的是地址值是否相等

Object的equals方法，默认比较两个引用类型的地址值是否相等，建议子类需要重写equals，重写之后比较的是两个对象的成员信息是否相同（Java中所有的类都会重写），重写equals方法，必须同时重写hashCode方法

clone：克隆

0bject的克隆方法：

protected 0bject clone() throws CloneNotSupportedException创建对象并返回它的"副本" ​ 方法里面本身就会带有CloneNotSupportedException:克隆不支持的异常(当要对某个Object的类进行克隆如果这个类不能实现cloneable接口，那么就会出现这个异常)

要进行创建对象的副本，前提是这个类必须实现clonable接口，否则无法克隆

jdk中提供的接口里面什么都没有，叫做标记接口

clonable接口就是标记哪些类可以实现克隆

native本地方法，非Java语言实现

2.Scanner提供的一个判断功能

Scanner文本扫描器

hasNextXXX():判断录入的是否为XXX类型

hasNextLine():判断录入的下一个数据为一行内容

InputMismatchException输入类型不匹配

先录入int,在录入String ----nextLine() , 这块会出现被漏掉("回车符号") 解决方案: 1)在第一个录 入int之后,重新创建一个新的键盘录入对象Scanner ,然后在使用nextLine() 2)在录入String---- String next()

3.String以及StringBuffer(字符串缓冲区)

String是一个常量，不可变的字符序列，一旦被赋值，其值不可更改

String类final修饰不能被继承

字符串不变，它们的值在被创建后不能被改变（字符串是一个常量，存在常量池）

构造方法

public String():空字符串 类似String s="";

public String(String original):构造一个字符串对象，里面指定一个字符串常量

public String(byte[] bytes):使用平台默认字符集(idea默认utf-8)解析解码--->字节数组--->字符串String(byte[] bytes,int offset, int length) :将一部分字节数组构造成字符串

public String(char[ ] value):将字符数组---构造成String

public String(char[] value,int offset,int len):将一部分字符串数组构造成字符串

constant pool常量池

instanceof 判断是否是实例

数组中没有length()，字符串中没有length(),集合中有没有？

集合中没有，获取集合中元素数size()

String s=new String("hello")和String s="hello"有什么区别？

String类型的形参不影响实际参数

字符串一旦被赋值，就是常量

前者:在堆内存中开辟空间,然后字符串值常量---指向常量池，两个对象

后者:推荐的方式，直接常量赋值，直接在常量池中找，有就返回地址，没有,开辟常量空间!

String类相关的获取功能

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

2. int length获取字符串的长度

3. public String concat(String str)拼接功能，将一个字符串拼接到指定字符串的后面

4. public String substring(int beginIndex)截取，从指定位置开始，到末尾结束

5. public String substring(int beginIndex，int endIndex)截取，从指定位置开始，到指定位置结束，括号包前不包后

6. public String[] split(String regex)拆分，按照指定的分隔符将字符串拆分成字符串数组

7. public int indexOf(int ch)返回此字符第一次在字符串出现的位置

8. public int lastIndexOf(int ch)返回此字符最后一次在字符串出现的位置

append追加

String类型的转化功能

1.char[] toCharArray()将字符串转换成字符数组

String s = "helloworld" ;
正在
l/char[] toCharArray()将字符串转换成字符数组
char[] chs = s.toCharArray();//i'h' , ' e ' , 'l', 'l', ' o ' , ' w ' , ' o ' , ' r' , 'l', ' d'}/ /Arrays:数组工具类---toString(任意类型数组)--转换成String
String resultStr = Arrays.toString(chs);
system.out.println(resultStr) ;

2.byte[] getBytes()默认字符集编码和String (byte[] bytes)默认字符集解码

byte[] getBytes(String charset)指定字符集编码和String (byte[] bytes,String charset)指定字符集解码

编码和解码必须一致

1. String (byte[] bytes)将字节数组转换为字符串

2. String (byte[] bytes，int index,int length)从字节数组的某个位置开始，指定长度，转换为字符串

3.public String toLowerCase()将字符串转成小写

public String toUpperCase()将字符串转成大写

4.valueOf万能方法，任意数据类型转化为字符串

平台默认utf-8（一个中文对应三个字符）

需求:给定一个字符串，输入"Hellowold"，输出"hELLOWORLD"

1)可以录入字符串s1 2)将字符串的一个字符截取出来s2 substring(0, 1) -->"H" ----->转换小写toLowerCase() 3)s1字符串subString(1) ----> "ellowold"--->转换成大写 toupperCase()-->s3 4)2)和3)结果----->concat拼接功能----->结果s4 5)输出

String的判断/替换/比较/去除两端空格( 了解)相关功能

判断功能:

boolean contains (String str):判断大串中是否包含指定子字符串 boolean endsWith(String:suffix):判断是否以指定结尾的字符串 public boolean startsWith(String prefix): 判断是否指定的字符串开头 boolean equalsIgnoreCase (String anotherString) : 不区分大小写比较两个字符串是否相同 public boolean isEmpty(): 判断字符串是否空，长度为, true 空串,和空对象?一样吗?不一样

替换功能

public String replace(char oldChar, char newChar) : 替换功能 public String trim() : 去除字符串两端空格(一般io流中: 文件读写复制)

比较

public int compareTo两个字符串按照字典顺序比较 两个字符串进行字典顺序比较，先算出长度，取出最小值，然后比较每一个字符，如果这俩个字符串的第一个字符都不相同使用前面的字符和后面的的字符进行相减(ASII码表的值相减) 如果长度的最小值，在循环遍历两个字符串的每一个字符之前，都相同，直接是两个字符串长度相减!

+字符串拼接符号

concat(String str) +更高效

String s=null;

s.concat("hello");左边不能为空对象，如果为空会导致空指针

2.StringBuffer(字符串缓冲区，线程安全的类)/StringBuilder

StringBuffer：线程安全的类，支持可变字符序列

线程依赖于进程，执行的最小单元

线程安全意味着同步，执行效率低；反之，效率高

1）构造方法

public StringBuffer()空参构造，初始容量16个字符

public StringBuffer(int capacity)指定容量大小的字符串缓冲区

public StringBuffer(String str)指定字符串内容构造到字符串缓冲区，容量=当前str长度+16

int length获取缓冲区长度

int capacity获取容量大小

2）StringBuffer的追加

public StringBuffer append()：将指定的类型追加字符串到缓冲区的序列中,返回自己本身

class A{
    public static void main(String[] args){
        StringBuffer s=new StringBuffer();
        s.append(100).append("wer").append("LK")
            System.out.println(s)
    }
}

3）StringBuffer的插入

public StringBuffer insert(int index,String str)可以插入任意类型，在指定位置的前面插入指定数据，返回字符串缓冲区本身

4）StringBuffer的替换

public StringBuffer replace(int start,int end,String str)可以是任意类型将start位置到end-1位置的字符序列进行替换

5）StringBuffer的特有功能

public StringBuffer reverse()将字符串缓冲区的字符序列进行反转

6）StringBuffer删除

public char charAt(int index):获取字符串缓冲区中指定位置的字符，返回指定的字符

StringBuffer delete(int start，int end):删除从指定位置开始到指定位置结束(end-1)的字符,返回字符串缓冲区本身

StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回值字符串缓冲区本身

7）StringBuffer转为String

StringBuffer buffer = new StringBuffer("helloJavaEE") ;

方式1: stringBuffer的成员方法public string tostring ()

stringBuffer buffer = new stringBuffer ( "abc" ) ;

string s = buffer.tostring ( ) ; 方式2: string的构造方法String (StringBuffer sb) stringBuffer buffer2 = new stringBuffer ( "abc") ;

string s2 = new String (buffer2) ;

8）String转为StringBuffer

使用StringBuffer(String str)有参构造

String a="wer";

StringBuffer s=new StringBuffer(a)

使用StringBuffer()空参构造，结合append(String str)追加

9)String和StringBuffer/StringBuilder的区别

String是一个常量，其值不能被改，不可变的字符序列

作为形参，不改变实际参数（和基本类型一致）

StringBuffer支持可变字符序列，字符串缓冲区，线程安全的类,执行效率低，作为形参，影响实际参数

大部分功能 synchronzied:同步锁（悲观锁）

StringBuilder和StringBuffer具备相互兼容的API，线程不安全的类，执行效率高

单线程只考虑效率，使用StringBuilder

多线程使用StringBuilder

10)截取功能

substring(int beginIndex,int endIndex): 返回一个字符串，该字符串是此字符串的子字符串。 子串开始于指定beginIndex并延伸到字符索引endIndex - 1 。

3.java.util.Date日期/Random随机数/System/Calendar日历/Bigdecimal小数精确计算

1.java.util.Date特定的日期

1）构造方法：

public Date()：系统时间的日期格式

2）成员方法

public long getTime()∶获取指定Date对象的系统时间毫秒值

格式化或解析：使用DateFormat类，他是抽象类，不能实例化，用抽象类的子类SimpleDateFormat(String pattern)

partten模式：yyyy年MM月dd月

HH小时数mm分钟数ss秒数

3）Date日期String格式化

public final String format(Date date)

Date date = new Date() ;
/ /SimpleDateFormat(String pattern):转换器
SimpleDateFormat sdf = new SimpleDateFormat( pattern:"yyyy-MMN-dd HH:mm: ss") ;
String dateStr = sdf.format(date);
system.out.println(dateStr);

public static String date2String(Date date,String pattern){
    return new simpleDateFormat(pattern).format(date) ;
}

1)创建当前日期对象 Date date2 = new Date (o) ;

2)创建解析器对象 simpleDateFormat sdf2 = new simpleDateFormat ("yyyy-MM-dd") ;

3)格式化 string datestr =sdf2 .format (sdf2) ;

4）String日期转为Date

ParseException解析异常

如果String日期文本和转换器SimplelDateFormat(String pattern)里面的模式不匹配就会造成解析异常!

string s = "2022-11-16";

1)创建解析器 simpleDateFomart sdf = new simpleDateFormat ("yyyy-MM-dd") ;

2 ) Date date = sdf.parse (s) ;

public static Date string2Date(String source ,String pattern) throws ParseException {
    return new simpleDateFormat(pattern).parse(source) ;
}

5）获取当前系统时间毫秒值

newTime

system类的静态方法

public static long currentTimeMillis()

String日期文本---->解析java.util.Date日期对象

6）自定义一个工具类

构造私有化,外界不能new 定义一个两个静态方法 调用jdk提供的一个类的方法---- 如果这个方法本身throws异常类名, 我们必须处理! 异常处理方式

1) throws : 抛出
2)开发中捕获异常
try{
可能出现问题的代码
}catch(异常类名对象名){
对象名. printStackTrice();跟踪堆栈.
}

2.System

不能实例化

三个变量，静态常量

static PrintStream err“标准”错误输出流l static InputStream in"标准”输入流。(InputStream:字节输入流--读数据) static PrintStream out“标准"输出流。(PrintStream字节打印流--->QutputStream字节输出流---写/打氏

PrintStream ps=Systen.out返回字节打印流：是字节流的一种io流

成员方法

1. public static long currentTimeMillis()获取系统时间毫秒值

2. public static void exit(int status):参数为0，正常终止jvm

3. gc()手动启动垃圾回收器，开启垃圾回收器，会调用Object类的finalize()垃圾回收方法

4. static void arraycopy(原数组，元素组中的某个位置，目标数组，目标数组中的某个位置，从原数组的那个位置srcPos指定长度复制到目标数组中)

final和finalize，finally有什么区别？

final状态修饰符，表示最终的，无法更改的，修饰类，不能被继承；修饰成员方法，不能被重写；修饰变量，成为常量

finalize是一个方法，Object类的方法，主要垃圾回收器没有更多引用对象，来释放空间

finally关键字：捕获异常标准格式：

try{

可能出现问题的代码

}catch（异常类名变量名）{

处理异常

}finally{

释放系统资源

Io流(创建文件、流对象都需要关闭)/jdbc(连接对象，执行对象，查询对象都需要close())

}

3.Random

伪随机数生成器

构造方法

public Random()：创建新的随机数生成器

成员方法

int nextInt()获取int类型的取值范围

int nextInt(int n):[0，n)随机数

4.集合--支持可变长度

只能存储引用类型

5.Integer

jdk5以后的新特性

范围-128-127

自动拆装箱：装箱：基本类型--自动提升引用类型

拆箱：引用类型--自动降为基本类型

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

1）Integer构造方法

1. public Integer(int value) :将int类型数据包装为Integer类型

2. public Integer(String s)throws NumberFormatException :将字符串类型包装Integer类型，如果字符串非数字字符串,就会出现NumberFormatExceptio数字格式化异常

2）装箱

Integer i=new Integer(XX);

3）拆箱

public int intValue()

4）Integer a=10和Integer i=new Integer(10)的区别

Integer a=X(int型)；执行底层的Integer.valueOf()---IntegerCache静态成员内部类(内部缓存区)---Low(-128)/high(127),超过范围，new Integer();重新创建Integer类对象，开辟内存空间

5）类型转换

int---String

方式一：字符串拼接“+”

方式二：int---Integer---String

Integer i=new Integer(i);

String a=i.toString();

方式三：静态方法public static String toString(int i)

String i=Integer.toString(i);

String----int

方式一：String---Integer---public int intValue()

Integer i=new Integer(i);

int value=i.intValue()

方式二：静态方法public static int parseInt(String s)

String i=Integer.parseInt(i);

parseXXX：任意类型都可以

6）十进制转换为其他进制字符串形式

public static String toBinaryString(int i):将十进制--转换二进制的字符串形式

public static string toHexString(int i)将十进制--转换十六进制的字符串形式

public static String to0ctalstring(int i)将十进制--转换八进制的字符串形式*/

6.Character

1）构造方法

Character(char value)包装一个char类型

2）成员方法

public static boolean isDigit(char ch)判断是否为数字字符

System.out.println(Character.isDigit( ch: '0') );

public static boolean isUpperCase(char ch)判断是否为大写字符

System.out.println(Character.isUpperCase( ch: 'A') );

public static boolean isLowerCase(char ch)判断是否为小写字符

System.out.println(Character.isLowerCase( ch: 'a') );

7.Calendar日历类/BigDecimal小数精确计算

java.util.Calendar日历类是一个抽象类

如果这个类是一个抽象类，这个类里面的某些功能（静态功能）--一定完成了这个类的子类的实例

创建日历实例：getInstance（）

Calendar提供静态的字段(成员变量--->静态常量)

public static final int DATE:月中的日期值=DAY_OF_MONTH

public static final int MONTH:年中的月份值(0-11)必须要+1

public static final int YEAR:年份值

Calendar提供成员方法:

获取日历的字段值

public int get(int field)

参数就是需要通过Calender访问静态常量的那些字段

给日历字段设置偏移量

添加或减去amount值

public abstract void add(int field,int amount)

add（year，-5）5年前

设置日历字段

public final

BigDecimal小数精确计算

构造方法

BigDecimal ( String value):参数"小数字符串值"

BigDecimal ( int value):参数"小数字整型值"

BigDecimal ( double value):参数"小数值"

成员方法:

1. public BigDecimal add(BigDecimal augend):加

2. public BigDecimal subtract(BigDecimal subtrahend)减

3. public BigDecimal multiply(BigDecimal multiplicand)乘

4. public BigDecimal divide(BigDecimal divisor):除

5. public BigDecimal divide(BigDecimal divisor除数值 ,int scale保留小数位数,int roundingMode舍入的模式)

jdk5新特性

静态导入：导入到方法的级别

import static 包名.类名.方法名；

前提使用静态导入，这个类必须为静态

在使用静态导入的时候，导入jdk提供的的一些工具类里面静态方法的时候，我们定义的方法不能和他的方法名冲突；如果冲突，静态导入不识别，这个时候必须导入全限定名称包名.类名.方法名

可变参数

当一个方法形式参数不知道有多少个，这个时候使用可变参数（类似一个数组）

abs求绝对值

集合和数组的区别

1. 长度区别：数组长度固定的

   集合长度是可变的

2. 存储数据类型的区别：

   1. 数组：皆可以存储基本类型，也可以存储引用类型，但是这些数组的类型必须一致

   2. 集合：只能存储引用数据类型，如果集合不带泛型，那么本身就可以存储任意类型数据

3. 存储元素的区别：

   1. 数组：存储必须一种类型的元素

   2. 集合：存储任意引用类型

8.Collection

没有jdk提供直接实现，通过具体的子接口list，set的子类实现

创建集合的时候<E>：里面存储的引用数据类型的元素

模拟数组，创建集合的时候就明确了集合中存储的数据类型

1.Collection基本功能

添加add()

删除：删除指定的元素boolean remove(Object o)

暴力清空void clear()

判断：isEmpty()判断集合是否为空

contains(Object o)判断集合是否包含指定元素

2.Collection的遍历

将集合转为字符数组

Object[] toArray

使用collection存储自定义对象（学生对象--针对学生类，进行遍历）

public static void main (String[] args) {
//创建一个集合--->存储String
    collection<String> c = new ArrayList<>() ;/添加字符串数据
    c.add("hello") ;
    c.add( "world" ) ;
    c.add( "javaEE") ;
    c.add( "Mysql") ;
    system.out.println(c);
//转换成数组0bject[] toArray()0bject[] objects = c.toArray();
    for(int x =0 ; x < objects.length ;x++){
        //objects[x]数组中---相当于每一个元素 0bject对象名 = new String();
        //多态向上转型l / system . out.println(objects[x]);
        //遍历这些字符串并且同时它的长度
        // system.out.println(objects[x]+" ---"+objects[x].length()); 
        //Object类型没有length()/向下转型
        String s = (String) objects[x];
        system.out.println(s+" ---"+s.length());
​
    }
}
​

@SuppressWarnings(all)压制警告

Collection的专有遍历方式：迭代器

Iterator接口提供了功能：Object next() 获取下一个可以遍历的元素

boolean hasNext():判断如果迭代器里面有元素,则返回true,然后在获取!

并发修改异常

java.util.ConcurrentModificationException:

出现原因：当使用迭代器去遍历元素的时候，不能同时使用集合操作元素

解决：

使用迭代器遍历，迭代器添加，但是现在Collection的迭代器没有添加功能----List集合的特有列表迭代器ListIterator

使用集合遍历，集合添加，Collection没有直接通过角标获取元素的功能

List集合Eget(int index) for(int x= ;x < list集合对象.size() ;x++){ String s = list集合对象.get(x) ;

if("world" ). equals(s){ ​ list集合对象.add( "javaee " ) ;

} }

9.List集合

特点

允许集合元素重复，而且有序集合(存取顺序一致)

三个子实现类特点

ArrayList:底层数据结构是数组-----查询快，增删慢

从线程来说，线程不安全，不同步，执行效率高

不明确使用什么集合（单线程）时默认使用

LinkedList：底层数据结构是链表---查询慢，增删快

从线程来说，线程不安全，不同步，执行效率高

当如果要去删除最后一个元素/将每一个元素添加集合开头时使用

Vector：底层结构是数组---查询快，增删慢

从线程来说，线程安全，同步，执行效率低（多线程使用）

List集合的特有功能

在指定位置后面插入新的元素：add(int index,element)

获取指定位置处的元素：get(int index)

在指定位置替换（修改）指定元素：set(int index,element)

列表迭代器-List专有遍历：ListIterator

ListIterator--->正向列表遍历 :boolean hasNext() + E next():获取下一个元素

ListIterator<String> lit = list.listIterator();
while(lit.hasNext()){
    string s = lit.next() ;//lit.next()只能使用一次，不能使用多次
    system.out.println(s+" ---"+s.length());
}
​

逆序遍历必须有正向遍历hasPrevious()

list集合中所有元素遍历

1. list集合继承Collection----Object[] toArray()

2. Collection的迭代器Iterator iterator()

3. 列表迭代器ListIterator

4. List集合的get+size的普通for循环

it.next()只能使用一次，不能使用多次

增强for

jdk5新特性，是为了替代迭代器，简化代码书写程度

特点：前提条件：集合或数组对象不能为null

for(泛型里面存储的数据类型 变量名：集合或者数组名称){

使用变量名

}

list去重

List存储自定义类型,

1. 而使用新建集合思想去重,contains()底层依赖Obejct的equals

2. 而Object的equals方法默认比较是==,两个对象地址值是否一样

3. 存储自定义类型保证元素唯一,自定义类型重写equals方法()/hashCode(),成员信息是否一样,如果一样,还要比较成员的哈希码值是否一样,如果都一样,那么就是同一个人

排序的思想

使用0角标对应的元素依次和后面元素比较,如果后面元素和前面的元素重复,将后面的元素干掉,(集合中remove(元素))

10.Vector和LinkeList的特有功能

Vector

Vector集合:线程安全的类(底层结构:数组,查询快,增删慢)

特有功能:

1.public void addELement(E obj)将指定的元素添加Vector集合中(默认追加) 2.public Enumeration<E> eLements(): 获取枚举组件接口----->类似FCollection集合的Iterator iterator() Enumeration接口 3.boolean hasMoreELements() 判断是否有元素-----> 类似于Iterator里面的boolean hasNext() 4.nextELement():获取下一个元素---->类似于Iterator里面的E next 5.public E eLementAt(int index): 通过索引值获取元素 ---->类似List集合的E get(int index) 6.int size(): 获取集合元素数

特有遍历方式

特有遍历方式1 for(int X =0; x < v.size() ;X++){ String s = V. eLementAt(x) ; System. out. printLn(s); } //特有遍历方式2 Enumeration<String> en = v. eLements(); while (en. hasMoreELements()){ String S = en. nextELement() ; System. out . printLn(s); }

LinkedList

线程不安全,不同步,执行效率高 底层数据结构:线程结构之链表,查询慢,增删快!

特有功能:

1. public void addFirst(E e)将指定的元素添加到链表的开头

2. public void addLast(E e)将指定的元素添加到链表的末尾

3. public E getFirst(): 获取第一个元素

4. public E getLast(): 获取最后一个元素

5. public E removeFirst(): 删除并返回第一个元素

6. public E removeLast(): 删除最后一个元素并返回

11.Set集合:唯一/无序(不能保证迭代顺序)

引入

HashSet--->哈希表--依赖于HashMap TreeSet---->红黑树--依赖TreeMap (自然排序/比较器排序:依赖于使用的构造方法)

Set集合:元素唯一的 默认情况使用HashSet进行实例(创建对象) HashSet的底层依赖HashMap(哈希表结构),元素唯一 ,迭代顺序无法保证的!

元素唯一

HashSet集合保证元素唯一 ---底层依赖HashMap的put方法---->依赖FhashCode()/equals(), 存储String类型,需要重写equals hashCode(),保证元素唯一!

TreeSet集合

Set集合的的实现类,它应该满足保证元素唯一 底层基于TreeMap<K,V>,它是一个红黑树(red-black-tree) 自然排序/比较器排序

构造方法:

public TreeSet():创建一个空的树,元素是按照自然排序顺序,里面的元素必须要实现Comparable接口

注意

要实现自然排序,那么使用TreeSet的无参构造方法,而且存的类型一定要实现Comparable接口,重写compareTo(T t)方法,完成比较

TreeSet存储Integer类型的元素

要实现自然排序,那么使用TreeSet的无参构造方法,而且存的类型一定 要实现Comparable接口,重写compareTo(T t)方法，完成比较

使用TreeSet存储自定义类型

存储的Student类型实现Comparable,完成自然排序!

使用TreeSet<Student>,按照自然排序排序

红黑树

是一个自平衡的二叉树的结构

public TreeSet(): 创建一个空的树,元素是按照自然排序顺序,里面的元素必须要实现Comparable接口

自然排序(默认使用的这种:大部分常用String/Integer/Character 都实现Comparable)

TreeSet<自定义类型>,如果要实现自然排序,使用TreeSet的无参构造方法 public TreeSet<E>() 自定义类型必须实现一个接口:Comparable<T>--->实现public int compareTo(T t){排序规则...}

比较器排序

自定义类实现Comparator

TreeSet有参构造方法 public TreeSet(Comparator<? super E> comparator)

比较器排序方式1:

自定义一个类实现Comparator接口 MyComparator my = new MyComparator() ; //具体类对象 Comparator<Student> my = new MyComparator() ; //接口多态 TreeSet<Student> ts = new TreeSet<>(my) ;

方式2:

public TreeSet(Comparator<? super E> comparator) 按照比较强排序,使用接口匿名内部类

TreeSet<自定义类型> ts = new TreeSet<>(new Comparator<自定义类型>(){ public int compare(自定义类型 t1,自定义类型 t2){排序规则...}

}) ;

字典顺序比较的逻辑

String字符串里面的compareTo(String str)逻辑 "hello" "abc" "hell" 这个方法:将字符串---->字符数组---->获取两个字符串长度的最小值(临界点) int k = 0 ; while( k < 长度最小值){

不断两个字符数组每一个字符 如果第一个字符值不同,直接方法结束: 返回 两个字符相减 (ASCII码表的值)

k++

如果循环结束之前,如果者两个字符串的都相同,返回字符串长度 相减

}

注意

当你有String数据,有int数据录入,防止出现先录入int,在录入String,String数据漏掉 全部使用String,---需要int---使用Integer.parseInt(数字字符串);

12.Map集合

大集合

HashMap<String,ArrayList<String>>

现在使用单列集合Collection<E></>--->List /Set List<Student>,本身就是将整个对象存储进去了,获取方式直接获取学生数据,遍历---->判断 所以Java提供 Map<K,V> 键值对,一个键(必须唯一)对应一个值(值可以重复)

Map和Collection的区别?

Collection<E>:单例集合,只能存储一种引用类型数据 遍历方式和Map不同; Collection集合的应用范围大: ArrayList Vector LinkedList

它里面的部分集合和Map有关联(HashSet--->依赖HashMap / TreeSet----> 依赖TreeMap) Map<K, V>,双列集合---->可以存储键值对("夫妻对") 遍历方式:通用方式获取所有的键,通过键找值!

应用范围:

HashMap---->存储和获取(默认使用) TreeMap---->存储---获取(按照排序规则排序) Map-->称为"实体" Map<Integer,Product>

Map(针对键有效,键必须唯一)的基本功能

添加:

V put(K key, V value):添加键值对元素,返回值什么意思? map针对键有效,键如果唯一的， 返回是null， 如果重复，将后面的键对应的值把前面的值覆盖了,返回第一次键对应的值

删除:

V remove(0bject key): 删除键,返回键对应的值 void clear(): 暴力删除,将map清空掉

判断:

boolean containsKey(object key): 判断Map集合是否包含指定的键,包含返回true,否则false boolean containsValue(0bject vaLue): 判断Map集合是否包含指定的值,包含则返回true,否则false boolean isEmpty() : 判断集合是否为空

遍历Map集合的方式

1)获取所有的键的集合

Set<String> keySet = map.keySet() ; for(String key:keySet){ //通过键获取值 String value = map.get(key); System.out.println(key+"---"+value) ; }

2)Set<Map. Entry<K, V>> entrySet() :获取Map结合的键值对对象

Set<Map . Entry<String，String>> entry = map. entrySet() ; for (Map . Entry<String，String> en: entry){ String key = en. getKey(); String value = en. getValue() ; System. out. println(key+"---"+value) ;

注意

1.HashMap---->put方法---->依赖hashCode()+equals()方法 能够保证键唯一!存储String,String类型重写了hashCode()+equals()方法,比较键的字符串内容是否相同!

2.如果K是自定义类型,要针对键有效,需要键的类型,需要重写equals和hashCode() equals():比较内容是否相同，hashCode(): 比较每一个成员信息的哈希码值是否一样

TreeMap

构造方法:

• public TreeMap():自然排序

• public TreeMap(Comparator<? super K> comparator):比较器排序

• 如果键是自定义类型,键必须唯一,而且需要有排序规则!

13.Collections:针对集合的操作工具类

java. util. Collections:针对集合操作工具类

常用的方法

1. 二分搜索法,在指定List集合中查询指定元素第一次出现索引值 ( 集合的元素有序) public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)

2. public static <T> T max(Collection<? extends T> coll): 针对Collection集合获取最大值(自然顺序比较获取最大值)

3. public static <T> T min(Collection<? extends T> coll): 针对Collection集合获取最小值(自然顺序比较获取最小值)

4. public static void reverse(List<?> list):将List集合的元素反转

5. public static void shuffle(List<?> list): 针对List集合随机置换

6. pubLic static <T extends Comparable<? super T>> void sort(List<T> List):针对L ist集合按照自然顺序排序

7. public static <T extends Comparable<? super T>> void sort(List<T> List,Comparator<T> com):针对List集合按照比较器排序

14.使用集合模板斗地主洗牌和发牌

1)发牌--->发到每个人的手上的牌无序

斗地主:三个玩家----54张牌, 底牌3张 不考虑三个玩家的手上牌有序的! 分析: 1)牌盒------------>ArrayList<String> 2)装牌 点数数组= {"A", "2", "3....... "10", "J", "Q", "K"} 花色数组= {"♥","♠","♣","♦"} 将每一个点数和花色拼接(concat(String str) 到一块"牌" 将"牌"添加牌盒中 单独添加"小王", "大王” 3)洗牌-------->将ArrayList随机置换---Collections的 public static void shuffle(List<?> list针对List集合随机置换 4)发牌: 三个玩家---->看成三个集合,每一个玩家就尽ArrayL ist<String> 底牌--->也可以成集合 A--->B--->C 规律: 遍历ArrayList.集合,里面去判断 for(int X =0; x <牌盒集合.size();x++ ){ if(x%3==0){ //玩家1 add(大集合的集合. get(x)) }else if(x%3==1){ //玩家2 }else if(x%3==2){ ... } } 调用用看牌的方法("玩家1",玩家1的集合) ; 调用用看牌的方法("玩家2",玩家2的集合) ; 调用用看牌的方法("玩家了",玩家3的集合) ;

5)看牌 定义一个方法 public static void LoolPoker(String name , ArrayL ist<String> array){ //xxx的牌是 将牌全部遍历出来,展示信息 }

public class PokerDemo {
    public static void main(String[] args) {
        ArrayList<String> pokerBox  = new ArrayList<>() ;
        String[] numbers = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"} ;
        String[] colors = {"♥","♠","♣","♦"} ;
        for(String color:colors){
            for(String number:numbers){
                String poker = color.concat(number);
                //添加pokerBox中
                pokerBox.add(poker) ;
            }
        }
        pokerBox.add("小王") ;
        pokerBox.add("大王") ;
        System.out.println(pokerBox) ;
        Collections.shuffle(pokerBox) ;
        System.out.println(pokerBox);
        ArrayList<String> player1 = new ArrayList<>() ;
        ArrayList<String> player2 = new ArrayList<>() ;
        ArrayList<String> player3 = new ArrayList<>() ;
        ArrayList<String> diPai = new ArrayList<>() ;
        for(int x = 0 ; x < pokerBox.size()  ;x++){
            if(x>= pokerBox.size()-3){
                diPai.add(pokerBox.get(x)) ;
            }else if(x%3==0){
                player1.add(pokerBox.get(x)) ;
            }else if(x%3==1){
                player2.add(pokerBox.get(x)) ;
            }else {
                player3.add(pokerBox.get(x)) ;
            }
        }
        lookPoker("高圆圆",player1) ;
        lookPoker("张杨",player2) ;
        lookPoker("赵又廷",player3) ;
        lookPoker("底牌",diPai) ;
    }
    public static void lookPoker(String name,ArrayList<String> array){
        System.out.print(name+"的牌是:\t" ) ;
        //遍历牌(ArrayList)
        for(String s:array){
            System.out.print(s+" ") ;
        }
        System.out.println();
    }
}

15.线程和进程

jvm是多线程

进程:

能够调用系统资源的独立单位!(打开任务管理器,查看进程状态)

多进程:

计算机都是支持多进程,提高CPU的使用率! 开启多个进程的时候,玩游戏的同时可以听音乐,他们并不是同时进行的,而是一点时间片在两个进程之间进行高效切换!

线程:

能够执行的最小单元!(一个线程可以看成进程的某个任务) 360软件---->开启---->开启进程 同时清理内存---同时查杀病毒

多线程的意义:

多个线程在互相抢占CPU执行权,线程的执行具有随机性!

jvm是多线程吗?

是一个多线程的,至少有两条线程 开启main线程---用户线程 gc----垃圾回收器 开启垃圾回收线程(回收没有更多的对象)

Java能够直接创建多线程吗?

创建线程---->需要创建进程---->需要使用系统资源创建进程 Java是不能够直接操作系统资源的,底层语記C是可以操作系统的 Jdk提供了Thread类,里面有个start()---->执行线程---底层非Java语言实现的

提供Thread类第一种创建线程的方式 1)自定义一个类继承的自Thread类 2)重写Thread类的run方法---->完成一些的耗时的操作 3)在main用户线程中,创建当前这个类对象 4)开启线程---->不是run方法,run方法它只是一个普通方法(仅仅执行线程里面的内容:读文件/完成io的操作...) 启动线程start()--->jvm是调用run线程的方法，结果是两个同时执行(具有随机性)

java. lang. IllegalThreadStateException非法线 程状态异常(一个线程不能启动多次)

Thread类提供一些基本功能:

public final void setName(String name):设置线程的名称 public final String getName():获取线程名称

优先级

public static final int MAX_PRIORITY 10最大优先级 public static final int MIN_PRIORITY 1最小优先级 public static final int NORM_ ,PRIORITY 5默认 优先级 优先级越大,线程抢占CPU执行权的几率越大!

给线程设置优先级

public final void setPriority(int newPriority)获取线程的优先级 public final int getPriority()

Java创建多线程方式

1)继承关系 Java提供的Thread类 2)实现关系 Runnable接口(方式2:使用Java设计模式之静态代理--设计模式之结构型设计模型的一种代理类/和被代理类都需要实现同一个接口)

线程的有几种状态

生命周期:就是线程从新建--->就绪--->执行---->死亡(终止)

1.常用类

1.常用类Object

哈希码值

int hashcode():（理解为地址值，不是实际地址值），支持散装列表（支持key--value键值对）

每一个对象的哈希码值都不一样

哈希算法：hash table

String toString()

返回对象的字符串表达形式，结果是描述成员信息表达式，建议所有子类重写

equals

boolean equals(Object obj)：比较两个数据（引用类型）是否相等

基本数据类型中==表示两个数据是否相等

==和equals区别

==比较两个基本类型，数据值是否相等

==连接两个引用类型，比较的是地址值是否相等

Object的equals方法，默认比较两个引用类型的地址值是否相等，建议子类需要重写equals，重写之后比较的是两个对象的成员信息是否相同（Java中所有的类都会重写），重写equals方法，必须同时重写hashCode方法

clone：克隆

0bject的克隆方法：

protected 0bject clone() throws CloneNotSupportedException创建对象并返回它的"副本" ​ 方法里面本身就会带有CloneNotSupportedException:克隆不支持的异常(当要对某个Object的类进行克隆如果这个类不能实现cloneable接口，那么就会出现这个异常)

要进行创建对象的副本，前提是这个类必须实现clonable接口，否则无法克隆

jdk中提供的接口里面什么都没有，叫做标记接口

clonable接口就是标记哪些类可以实现克隆

native本地方法，非Java语言实现

2.Scanner提供的一个判断功能

Scanner文本扫描器

hasNextXXX():判断录入的是否为XXX类型

hasNextLine():判断录入的下一个数据为一行内容

InputMismatchException输入类型不匹配

先录入int,在录入String ----nextLine() , 这块会出现被漏掉("回车符号") 解决方案: 1)在第一个录 入int之后,重新创建一个新的键盘录入对象Scanner ,然后在使用nextLine() 2)在录入String---- String next()

3.String以及StringBuffer(字符串缓冲区)

String是一个常量，不可变的字符序列，一旦被赋值，其值不可更改

String类final修饰不能被继承

字符串不变，它们的值在被创建后不能被改变（字符串是一个常量，存在常量池）

构造方法

public String():空字符串 类似String s="";

public String(String original):构造一个字符串对象，里面指定一个字符串常量

public String(byte[] bytes):使用平台默认字符集(idea默认utf-8)解析解码--->字节数组--->字符串String(byte[] bytes,int offset, int length) :将一部分字节数组构造成字符串

public String(char[ ] value):将字符数组---构造成String

public String(char[] value,int offset,int len):将一部分字符串数组构造成字符串

constant pool常量池

instanceof 判断是否是实例

数组中没有length()，字符串中没有length(),集合中有没有？

集合中没有，获取集合中元素数size()

String s=new String("hello")和String s="hello"有什么区别？

String类型的形参不影响实际参数

字符串一旦被赋值，就是常量

前者:在堆内存中开辟空间,然后字符串值常量---指向常量池，两个对象

后者:推荐的方式，直接常量赋值，直接在常量池中找，有就返回地址，没有,开辟常量空间!

String类相关的获取功能

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

2. int length获取字符串的长度

3. public String concat(String str)拼接功能，将一个字符串拼接到指定字符串的后面

4. public String substring(int beginIndex)截取，从指定位置开始，到末尾结束

5. public String substring(int beginIndex，int endIndex)截取，从指定位置开始，到指定位置结束，括号包前不包后

6. public String[] split(String regex)拆分，按照指定的分隔符将字符串拆分成字符串数组

7. public int indexOf(int ch)返回此字符第一次在字符串出现的位置

8. public int lastIndexOf(int ch)返回此字符最后一次在字符串出现的位置

append追加

String类型的转化功能

1.char[] toCharArray()将字符串转换成字符数组

String s = "helloworld" ;
正在
l/char[] toCharArray()将字符串转换成字符数组
char[] chs = s.toCharArray();//i'h' , ' e ' , 'l', 'l', ' o ' , ' w ' , ' o ' , ' r' , 'l', ' d'}/ /Arrays:数组工具类---toString(任意类型数组)--转换成String
String resultStr = Arrays.toString(chs);
system.out.println(resultStr) ;

2.byte[] getBytes()默认字符集编码和String (byte[] bytes)默认字符集解码

byte[] getBytes(String charset)指定字符集编码和String (byte[] bytes,String charset)指定字符集解码

编码和解码必须一致

1. String (byte[] bytes)将字节数组转换为字符串

2. String (byte[] bytes，int index,int length)从字节数组的某个位置开始，指定长度，转换为字符串

3.public String toLowerCase()将字符串转成小写

public String toUpperCase()将字符串转成大写

4.valueOf万能方法，任意数据类型转化为字符串

平台默认utf-8（一个中文对应三个字符）

需求:给定一个字符串，输入"Hellowold"，输出"hELLOWORLD"

1)可以录入字符串s1 2)将字符串的一个字符截取出来s2 substring(0, 1) -->"H" ----->转换小写toLowerCase() 3)s1字符串subString(1) ----> "ellowold"--->转换成大写 toupperCase()-->s3 4)2)和3)结果----->concat拼接功能----->结果s4 5)输出

String的判断/替换/比较/去除两端空格( 了解)相关功能

判断功能:

boolean contains (String str):判断大串中是否包含指定子字符串 boolean endsWith(String:suffix):判断是否以指定结尾的字符串 public boolean startsWith(String prefix): 判断是否指定的字符串开头 boolean equalsIgnoreCase (String anotherString) : 不区分大小写比较两个字符串是否相同 public boolean isEmpty(): 判断字符串是否空，长度为, true 空串,和空对象?一样吗?不一样

替换功能

public String replace(char oldChar, char newChar) : 替换功能 public String trim() : 去除字符串两端空格(一般io流中: 文件读写复制)

比较

public int compareTo两个字符串按照字典顺序比较 两个字符串进行字典顺序比较，先算出长度，取出最小值，然后比较每一个字符，如果这俩个字符串的第一个字符都不相同使用前面的字符和后面的的字符进行相减(ASII码表的值相减) 如果长度的最小值，在循环遍历两个字符串的每一个字符之前，都相同，直接是两个字符串长度相减!

+字符串拼接符号

concat(String str) +更高效

String s=null;

s.concat("hello");左边不能为空对象，如果为空会导致空指针

2.StringBuffer(字符串缓冲区，线程安全的类)/StringBuilder

StringBuffer：线程安全的类，支持可变字符序列

线程依赖于进程，执行的最小单元

线程安全意味着同步，执行效率低；反之，效率高

1）构造方法

public StringBuffer()空参构造，初始容量16个字符

public StringBuffer(int capacity)指定容量大小的字符串缓冲区

public StringBuffer(String str)指定字符串内容构造到字符串缓冲区，容量=当前str长度+16

int length获取缓冲区长度

int capacity获取容量大小

2）StringBuffer的追加

public StringBuffer append()：将指定的类型追加字符串到缓冲区的序列中,返回自己本身

class A{
    public static void main(String[] args){
        StringBuffer s=new StringBuffer();
        s.append(100).append("wer").append("LK")
            System.out.println(s)
    }
}

3）StringBuffer的插入

public StringBuffer insert(int index,String str)可以插入任意类型，在指定位置的前面插入指定数据，返回字符串缓冲区本身

4）StringBuffer的替换

public StringBuffer replace(int start,int end,String str)可以是任意类型将start位置到end-1位置的字符序列进行替换

5）StringBuffer的特有功能

public StringBuffer reverse()将字符串缓冲区的字符序列进行反转

6）StringBuffer删除

public char charAt(int index):获取字符串缓冲区中指定位置的字符，返回指定的字符

StringBuffer delete(int start，int end):删除从指定位置开始到指定位置结束(end-1)的字符,返回字符串缓冲区本身

StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回值字符串缓冲区本身

7）StringBuffer转为String

StringBuffer buffer = new StringBuffer("helloJavaEE") ;

方式1: stringBuffer的成员方法public string tostring ()

stringBuffer buffer = new stringBuffer ( "abc" ) ;

string s = buffer.tostring ( ) ; 方式2: string的构造方法String (StringBuffer sb) stringBuffer buffer2 = new stringBuffer ( "abc") ;

string s2 = new String (buffer2) ;

8）String转为StringBuffer

使用StringBuffer(String str)有参构造

String a="wer";

StringBuffer s=new StringBuffer(a)

使用StringBuffer()空参构造，结合append(String str)追加

9)String和StringBuffer/StringBuilder的区别

String是一个常量，其值不能被改，不可变的字符序列

作为形参，不改变实际参数（和基本类型一致）

StringBuffer支持可变字符序列，字符串缓冲区，线程安全的类,执行效率低，作为形参，影响实际参数

大部分功能 synchronzied:同步锁（悲观锁）

StringBuilder和StringBuffer具备相互兼容的API，线程不安全的类，执行效率高

单线程只考虑效率，使用StringBuilder

多线程使用StringBuilder

10)截取功能

substring(int beginIndex,int endIndex): 返回一个字符串，该字符串是此字符串的子字符串。 子串开始于指定beginIndex并延伸到字符索引endIndex - 1 。

3.java.util.Date日期/Random随机数/System/Calendar日历/Bigdecimal小数精确计算

1.java.util.Date特定的日期

1）构造方法：

public Date()：系统时间的日期格式

2）成员方法

public long getTime()∶获取指定Date对象的系统时间毫秒值

格式化或解析：使用DateFormat类，他是抽象类，不能实例化，用抽象类的子类SimpleDateFormat(String pattern)

partten模式：yyyy年MM月dd月

HH小时数mm分钟数ss秒数

3）Date日期String格式化

public final String format(Date date)

Date date = new Date() ;
/ /SimpleDateFormat(String pattern):转换器
SimpleDateFormat sdf = new SimpleDateFormat( pattern:"yyyy-MMN-dd HH:mm: ss") ;
String dateStr = sdf.format(date);
system.out.println(dateStr);

public static String date2String(Date date,String pattern){
    return new simpleDateFormat(pattern).format(date) ;
}

1)创建当前日期对象 Date date2 = new Date (o) ;

2)创建解析器对象 simpleDateFormat sdf2 = new simpleDateFormat ("yyyy-MM-dd") ;

3)格式化 string datestr =sdf2 .format (sdf2) ;

4）String日期转为Date

ParseException解析异常

如果String日期文本和转换器SimplelDateFormat(String pattern)里面的模式不匹配就会造成解析异常!

string s = "2022-11-16";

1)创建解析器 simpleDateFomart sdf = new simpleDateFormat ("yyyy-MM-dd") ;

2 ) Date date = sdf.parse (s) ;

public static Date string2Date(String source ,String pattern) throws ParseException {
    return new simpleDateFormat(pattern).parse(source) ;
}

5）获取当前系统时间毫秒值

newTime

system类的静态方法

public static long currentTimeMillis()

String日期文本---->解析java.util.Date日期对象

6）自定义一个工具类

构造私有化,外界不能new 定义一个两个静态方法 调用jdk提供的一个类的方法---- 如果这个方法本身throws异常类名, 我们必须处理! 异常处理方式

1) throws : 抛出
2)开发中捕获异常
try{
可能出现问题的代码
}catch(异常类名对象名){
对象名. printStackTrice();跟踪堆栈.
}

2.System

不能实例化

三个变量，静态常量

static PrintStream err“标准”错误输出流l static InputStream in"标准”输入流。(InputStream:字节输入流--读数据) static PrintStream out“标准"输出流。(PrintStream字节打印流--->QutputStream字节输出流---写/打氏

PrintStream ps=Systen.out返回字节打印流：是字节流的一种io流

成员方法

1. public static long currentTimeMillis()获取系统时间毫秒值

2. public static void exit(int status):参数为0，正常终止jvm

3. gc()手动启动垃圾回收器，开启垃圾回收器，会调用Object类的finalize()垃圾回收方法

4. static void arraycopy(原数组，元素组中的某个位置，目标数组，目标数组中的某个位置，从原数组的那个位置srcPos指定长度复制到目标数组中)

final和finalize，finally有什么区别？

final状态修饰符，表示最终的，无法更改的，修饰类，不能被继承；修饰成员方法，不能被重写；修饰变量，成为常量

finalize是一个方法，Object类的方法，主要垃圾回收器没有更多引用对象，来释放空间

finally关键字：捕获异常标准格式：

try{

可能出现问题的代码

}catch（异常类名变量名）{

处理异常

}finally{

释放系统资源

Io流(创建文件、流对象都需要关闭)/jdbc(连接对象，执行对象，查询对象都需要close())

}

3.Random

伪随机数生成器

构造方法

public Random()：创建新的随机数生成器

成员方法

int nextInt()获取int类型的取值范围

int nextInt(int n):[0，n)随机数

4.集合--支持可变长度

只能存储引用类型

5.Integer

jdk5以后的新特性

范围-128-127

自动拆装箱：装箱：基本类型--自动提升引用类型

拆箱：引用类型--自动降为基本类型

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

1）Integer构造方法

1. public Integer(int value) :将int类型数据包装为Integer类型

2. public Integer(String s)throws NumberFormatException :将字符串类型包装Integer类型，如果字符串非数字字符串,就会出现NumberFormatExceptio数字格式化异常

2）装箱

Integer i=new Integer(XX);

3）拆箱

public int intValue()

4）Integer a=10和Integer i=new Integer(10)的区别

Integer a=X(int型)；执行底层的Integer.valueOf()---IntegerCache静态成员内部类(内部缓存区)---Low(-128)/high(127),超过范围，new Integer();重新创建Integer类对象，开辟内存空间

5）类型转换

int---String

方式一：字符串拼接“+”

方式二：int---Integer---String

Integer i=new Integer(i);

String a=i.toString();

方式三：静态方法public static String toString(int i)

String i=Integer.toString(i);

String----int

方式一：String---Integer---public int intValue()

Integer i=new Integer(i);

int value=i.intValue()

方式二：静态方法public static int parseInt(String s)

String i=Integer.parseInt(i);

parseXXX：任意类型都可以

6）十进制转换为其他进制字符串形式

public static String toBinaryString(int i):将十进制--转换二进制的字符串形式

public static string toHexString(int i)将十进制--转换十六进制的字符串形式

public static String to0ctalstring(int i)将十进制--转换八进制的字符串形式*/

6.Character

1）构造方法

Character(char value)包装一个char类型

2）成员方法

public static boolean isDigit(char ch)判断是否为数字字符

System.out.println(Character.isDigit( ch: '0') );

public static boolean isUpperCase(char ch)判断是否为大写字符

System.out.println(Character.isUpperCase( ch: 'A') );

public static boolean isLowerCase(char ch)判断是否为小写字符

System.out.println(Character.isLowerCase( ch: 'a') );

7.Calendar日历类/BigDecimal小数精确计算

java.util.Calendar日历类是一个抽象类

如果这个类是一个抽象类，这个类里面的某些功能（静态功能）--一定完成了这个类的子类的实例

创建日历实例：getInstance（）

Calendar提供静态的字段(成员变量--->静态常量)

public static final int DATE:月中的日期值=DAY_OF_MONTH

public static final int MONTH:年中的月份值(0-11)必须要+1

public static final int YEAR:年份值

Calendar提供成员方法:

获取日历的字段值

public int get(int field)

参数就是需要通过Calender访问静态常量的那些字段

给日历字段设置偏移量

添加或减去amount值

public abstract void add(int field,int amount)

add（year，-5）5年前

设置日历字段

public final

BigDecimal小数精确计算

构造方法

BigDecimal ( String value):参数"小数字符串值"

BigDecimal ( int value):参数"小数字整型值"

BigDecimal ( double value):参数"小数值"

成员方法:

1. public BigDecimal add(BigDecimal augend):加

2. public BigDecimal subtract(BigDecimal subtrahend)减

3. public BigDecimal multiply(BigDecimal multiplicand)乘

4. public BigDecimal divide(BigDecimal divisor):除

5. public BigDecimal divide(BigDecimal divisor除数值 ,int scale保留小数位数,int roundingMode舍入的模式)

jdk5新特性

静态导入：导入到方法的级别

import static 包名.类名.方法名；

前提使用静态导入，这个类必须为静态

在使用静态导入的时候，导入jdk提供的的一些工具类里面静态方法的时候，我们定义的方法不能和他的方法名冲突；如果冲突，静态导入不识别，这个时候必须导入全限定名称包名.类名.方法名

可变参数

当一个方法形式参数不知道有多少个，这个时候使用可变参数（类似一个数组）

abs求绝对值

集合和数组的区别

1. 长度区别：数组长度固定的

   集合长度是可变的

2. 存储数据类型的区别：

   1. 数组：皆可以存储基本类型，也可以存储引用类型，但是这些数组的类型必须一致

   2. 集合：只能存储引用数据类型，如果集合不带泛型，那么本身就可以存储任意类型数据

3. 存储元素的区别：

   1. 数组：存储必须一种类型的元素

   2. 集合：存储任意引用类型

8.Collection

没有jdk提供直接实现，通过具体的子接口list，set的子类实现

创建集合的时候<E>：里面存储的引用数据类型的元素

模拟数组，创建集合的时候就明确了集合中存储的数据类型

1.Collection基本功能

添加add()

删除：删除指定的元素boolean remove(Object o)

暴力清空void clear()

判断：isEmpty()判断集合是否为空

contains(Object o)判断集合是否包含指定元素

2.Collection的遍历

将集合转为字符数组

Object[] toArray

使用collection存储自定义对象（学生对象--针对学生类，进行遍历）

public static void main (String[] args) {
//创建一个集合--->存储String
    collection<String> c = new ArrayList<>() ;/添加字符串数据
    c.add("hello") ;
    c.add( "world" ) ;
    c.add( "javaEE") ;
    c.add( "Mysql") ;
    system.out.println(c);
//转换成数组0bject[] toArray()0bject[] objects = c.toArray();
    for(int x =0 ; x < objects.length ;x++){
        //objects[x]数组中---相当于每一个元素 0bject对象名 = new String();
        //多态向上转型l / system . out.println(objects[x]);
        //遍历这些字符串并且同时它的长度
        // system.out.println(objects[x]+" ---"+objects[x].length()); 
        //Object类型没有length()/向下转型
        String s = (String) objects[x];
        system.out.println(s+" ---"+s.length());
​
    }
}
​

@SuppressWarnings(all)压制警告

Collection的专有遍历方式：迭代器

Iterator接口提供了功能：Object next() 获取下一个可以遍历的元素

boolean hasNext():判断如果迭代器里面有元素,则返回true,然后在获取!

并发修改异常

java.util.ConcurrentModificationException:

出现原因：当使用迭代器去遍历元素的时候，不能同时使用集合操作元素

解决：

使用迭代器遍历，迭代器添加，但是现在Collection的迭代器没有添加功能----List集合的特有列表迭代器ListIterator

使用集合遍历，集合添加，Collection没有直接通过角标获取元素的功能

List集合Eget(int index) for(int x= ;x < list集合对象.size() ;x++){ String s = list集合对象.get(x) ;

if("world" ). equals(s){ ​ list集合对象.add( "javaee " ) ;

} }

9.List集合

特点

允许集合元素重复，而且有序集合(存取顺序一致)

三个子实现类特点

ArrayList:底层数据结构是数组-----查询快，增删慢

从线程来说，线程不安全，不同步，执行效率高

不明确使用什么集合（单线程）时默认使用

LinkedList：底层数据结构是链表---查询慢，增删快

从线程来说，线程不安全，不同步，执行效率高

当如果要去删除最后一个元素/将每一个元素添加集合开头时使用

Vector：底层结构是数组---查询快，增删慢

从线程来说，线程安全，同步，执行效率低（多线程使用）

List集合的特有功能

在指定位置后面插入新的元素：add(int index,element)

获取指定位置处的元素：get(int index)

在指定位置替换（修改）指定元素：set(int index,element)

列表迭代器-List专有遍历：ListIterator

ListIterator--->正向列表遍历 :boolean hasNext() + E next():获取下一个元素

ListIterator<String> lit = list.listIterator();
while(lit.hasNext()){
    string s = lit.next() ;//lit.next()只能使用一次，不能使用多次
    system.out.println(s+" ---"+s.length());
}
​

逆序遍历必须有正向遍历hasPrevious()

list集合中所有元素遍历

1. list集合继承Collection----Object[] toArray()

2. Collection的迭代器Iterator iterator()

3. 列表迭代器ListIterator

4. List集合的get+size的普通for循环

it.next()只能使用一次，不能使用多次

增强for

jdk5新特性，是为了替代迭代器，简化代码书写程度

特点：前提条件：集合或数组对象不能为null

for(泛型里面存储的数据类型 变量名：集合或者数组名称){

使用变量名

}

list去重

List存储自定义类型,

1. 而使用新建集合思想去重,contains()底层依赖Obejct的equals

2. 而Object的equals方法默认比较是==,两个对象地址值是否一样

3. 存储自定义类型保证元素唯一,自定义类型重写equals方法()/hashCode(),成员信息是否一样,如果一样,还要比较成员的哈希码值是否一样,如果都一样,那么就是同一个人

排序的思想

使用0角标对应的元素依次和后面元素比较,如果后面元素和前面的元素重复,将后面的元素干掉,(集合中remove(元素))

10.Vector和LinkeList的特有功能

Vector

Vector集合:线程安全的类(底层结构:数组,查询快,增删慢)

特有功能:

1.public void addELement(E obj)将指定的元素添加Vector集合中(默认追加) 2.public Enumeration<E> eLements(): 获取枚举组件接口----->类似FCollection集合的Iterator iterator() Enumeration接口 3.boolean hasMoreELements() 判断是否有元素-----> 类似于Iterator里面的boolean hasNext() 4.nextELement():获取下一个元素---->类似于Iterator里面的E next 5.public E eLementAt(int index): 通过索引值获取元素 ---->类似List集合的E get(int index) 6.int size(): 获取集合元素数

特有遍历方式

特有遍历方式1 for(int X =0; x < v.size() ;X++){ String s = V. eLementAt(x) ; System. out. printLn(s); } //特有遍历方式2 Enumeration<String> en = v. eLements(); while (en. hasMoreELements()){ String S = en. nextELement() ; System. out . printLn(s); }

LinkedList

线程不安全,不同步,执行效率高 底层数据结构:线程结构之链表,查询慢,增删快!

特有功能:

1. public void addFirst(E e)将指定的元素添加到链表的开头

2. public void addLast(E e)将指定的元素添加到链表的末尾

3. public E getFirst(): 获取第一个元素

4. public E getLast(): 获取最后一个元素

5. public E removeFirst(): 删除并返回第一个元素

6. public E removeLast(): 删除最后一个元素并返回

11.Set集合:唯一/无序(不能保证迭代顺序)

引入

HashSet--->哈希表--依赖于HashMap TreeSet---->红黑树--依赖TreeMap (自然排序/比较器排序:依赖于使用的构造方法)

Set集合:元素唯一的 默认情况使用HashSet进行实例(创建对象) HashSet的底层依赖HashMap(哈希表结构),元素唯一 ,迭代顺序无法保证的!

元素唯一

HashSet集合保证元素唯一 ---底层依赖HashMap的put方法---->依赖FhashCode()/equals(), 存储String类型,需要重写equals hashCode(),保证元素唯一!

TreeSet集合

Set集合的的实现类,它应该满足保证元素唯一 底层基于TreeMap<K,V>,它是一个红黑树(red-black-tree) 自然排序/比较器排序

构造方法:

public TreeSet():创建一个空的树,元素是按照自然排序顺序,里面的元素必须要实现Comparable接口

注意

要实现自然排序,那么使用TreeSet的无参构造方法,而且存的类型一定要实现Comparable接口,重写compareTo(T t)方法,完成比较

TreeSet存储Integer类型的元素

要实现自然排序,那么使用TreeSet的无参构造方法,而且存的类型一定 要实现Comparable接口,重写compareTo(T t)方法，完成比较

使用TreeSet存储自定义类型

存储的Student类型实现Comparable,完成自然排序!

使用TreeSet<Student>,按照自然排序排序

红黑树

是一个自平衡的二叉树的结构

public TreeSet(): 创建一个空的树,元素是按照自然排序顺序,里面的元素必须要实现Comparable接口

自然排序(默认使用的这种:大部分常用String/Integer/Character 都实现Comparable)

TreeSet<自定义类型>,如果要实现自然排序,使用TreeSet的无参构造方法 public TreeSet<E>() 自定义类型必须实现一个接口:Comparable<T>--->实现public int compareTo(T t){排序规则...}

比较器排序

自定义类实现Comparator

TreeSet有参构造方法 public TreeSet(Comparator<? super E> comparator)

比较器排序方式1:

自定义一个类实现Comparator接口 MyComparator my = new MyComparator() ; //具体类对象 Comparator<Student> my = new MyComparator() ; //接口多态 TreeSet<Student> ts = new TreeSet<>(my) ;

方式2:

public TreeSet(Comparator<? super E> comparator) 按照比较强排序,使用接口匿名内部类

TreeSet<自定义类型> ts = new TreeSet<>(new Comparator<自定义类型>(){ public int compare(自定义类型 t1,自定义类型 t2){排序规则...}

}) ;

字典顺序比较的逻辑

String字符串里面的compareTo(String str)逻辑 "hello" "abc" "hell" 这个方法:将字符串---->字符数组---->获取两个字符串长度的最小值(临界点) int k = 0 ; while( k < 长度最小值){

不断两个字符数组每一个字符 如果第一个字符值不同,直接方法结束: 返回 两个字符相减 (ASCII码表的值)

k++

如果循环结束之前,如果者两个字符串的都相同,返回字符串长度 相减

}

注意

当你有String数据,有int数据录入,防止出现先录入int,在录入String,String数据漏掉 全部使用String,---需要int---使用Integer.parseInt(数字字符串);

12.Map集合

大集合

HashMap<String,ArrayList<String>>

现在使用单列集合Collection<E></>--->List /Set List<Student>,本身就是将整个对象存储进去了,获取方式直接获取学生数据,遍历---->判断 所以Java提供 Map<K,V> 键值对,一个键(必须唯一)对应一个值(值可以重复)

Map和Collection的区别?

Collection<E>:单例集合,只能存储一种引用类型数据 遍历方式和Map不同; Collection集合的应用范围大: ArrayList Vector LinkedList

它里面的部分集合和Map有关联(HashSet--->依赖HashMap / TreeSet----> 依赖TreeMap) Map<K, V>,双列集合---->可以存储键值对("夫妻对") 遍历方式:通用方式获取所有的键,通过键找值!

应用范围:

HashMap---->存储和获取(默认使用) TreeMap---->存储---获取(按照排序规则排序) Map-->称为"实体" Map<Integer,Product>

Map(针对键有效,键必须唯一)的基本功能

添加:

V put(K key, V value):添加键值对元素,返回值什么意思? map针对键有效,键如果唯一的， 返回是null， 如果重复，将后面的键对应的值把前面的值覆盖了,返回第一次键对应的值

删除:

V remove(0bject key): 删除键,返回键对应的值 void clear(): 暴力删除,将map清空掉

判断:

boolean containsKey(object key): 判断Map集合是否包含指定的键,包含返回true,否则false boolean containsValue(0bject vaLue): 判断Map集合是否包含指定的值,包含则返回true,否则false boolean isEmpty() : 判断集合是否为空

遍历Map集合的方式

1)获取所有的键的集合

Set<String> keySet = map.keySet() ; for(String key:keySet){ //通过键获取值 String value = map.get(key); System.out.println(key+"---"+value) ; }

2)Set<Map. Entry<K, V>> entrySet() :获取Map结合的键值对对象

Set<Map . Entry<String，String>> entry = map. entrySet() ; for (Map . Entry<String，String> en: entry){ String key = en. getKey(); String value = en. getValue() ; System. out. println(key+"---"+value) ;

注意

1.HashMap---->put方法---->依赖hashCode()+equals()方法 能够保证键唯一!存储String,String类型重写了hashCode()+equals()方法,比较键的字符串内容是否相同!

2.如果K是自定义类型,要针对键有效,需要键的类型,需要重写equals和hashCode() equals():比较内容是否相同，hashCode(): 比较每一个成员信息的哈希码值是否一样

TreeMap

构造方法:

• public TreeMap():自然排序

• public TreeMap(Comparator<? super K> comparator):比较器排序

• 如果键是自定义类型,键必须唯一,而且需要有排序规则!

13.Collections:针对集合的操作工具类

java. util. Collections:针对集合操作工具类

常用的方法

1. 二分搜索法,在指定List集合中查询指定元素第一次出现索引值 ( 集合的元素有序) public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)

2. public static <T> T max(Collection<? extends T> coll): 针对Collection集合获取最大值(自然顺序比较获取最大值)

3. public static <T> T min(Collection<? extends T> coll): 针对Collection集合获取最小值(自然顺序比较获取最小值)

4. public static void reverse(List<?> list):将List集合的元素反转

5. public static void shuffle(List<?> list): 针对List集合随机置换

6. pubLic static <T extends Comparable<? super T>> void sort(List<T> List):针对L ist集合按照自然顺序排序

7. public static <T extends Comparable<? super T>> void sort(List<T> List,Comparator<T> com):针对List集合按照比较器排序

14.使用集合模板斗地主洗牌和发牌

1)发牌--->发到每个人的手上的牌无序

斗地主:三个玩家----54张牌, 底牌3张 不考虑三个玩家的手上牌有序的! 分析: 1)牌盒------------>ArrayList<String> 2)装牌 点数数组= {"A", "2", "3....... "10", "J", "Q", "K"} 花色数组= {"♥","♠","♣","♦"} 将每一个点数和花色拼接(concat(String str) 到一块"牌" 将"牌"添加牌盒中 单独添加"小王", "大王” 3)洗牌-------->将ArrayList随机置换---Collections的 public static void shuffle(List<?> list针对List集合随机置换 4)发牌: 三个玩家---->看成三个集合,每一个玩家就尽ArrayL ist<String> 底牌--->也可以成集合 A--->B--->C 规律: 遍历ArrayList.集合,里面去判断 for(int X =0; x <牌盒集合.size();x++ ){ if(x%3==0){ //玩家1 add(大集合的集合. get(x)) }else if(x%3==1){ //玩家2 }else if(x%3==2){ ... } } 调用用看牌的方法("玩家1",玩家1的集合) ; 调用用看牌的方法("玩家2",玩家2的集合) ; 调用用看牌的方法("玩家了",玩家3的集合) ;

5)看牌 定义一个方法 public static void LoolPoker(String name , ArrayL ist<String> array){ //xxx的牌是 将牌全部遍历出来,展示信息 }

public class PokerDemo {
    public static void main(String[] args) {
        ArrayList<String> pokerBox  = new ArrayList<>() ;
        String[] numbers = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"} ;
        String[] colors = {"♥","♠","♣","♦"} ;
        for(String color:colors){
            for(String number:numbers){
                String poker = color.concat(number);
                //添加pokerBox中
                pokerBox.add(poker) ;
            }
        }
        pokerBox.add("小王") ;
        pokerBox.add("大王") ;
        System.out.println(pokerBox) ;
        Collections.shuffle(pokerBox) ;
        System.out.println(pokerBox);
        ArrayList<String> player1 = new ArrayList<>() ;
        ArrayList<String> player2 = new ArrayList<>() ;
        ArrayList<String> player3 = new ArrayList<>() ;
        ArrayList<String> diPai = new ArrayList<>() ;
        for(int x = 0 ; x < pokerBox.size()  ;x++){
            if(x>= pokerBox.size()-3){
                diPai.add(pokerBox.get(x)) ;
            }else if(x%3==0){
                player1.add(pokerBox.get(x)) ;
            }else if(x%3==1){
                player2.add(pokerBox.get(x)) ;
            }else {
                player3.add(pokerBox.get(x)) ;
            }
        }
        lookPoker("高圆圆",player1) ;
        lookPoker("张杨",player2) ;
        lookPoker("赵又廷",player3) ;
        lookPoker("底牌",diPai) ;
    }
    public static void lookPoker(String name,ArrayList<String> array){
        System.out.print(name+"的牌是:\t" ) ;
        //遍历牌(ArrayList)
        for(String s:array){
            System.out.print(s+" ") ;
        }
        System.out.println();
    }
}

15.线程和进程

jvm是多线程

进程:

能够调用系统资源的独立单位!(打开任务管理器,查看进程状态)

多进程:

计算机都是支持多进程,提高CPU的使用率! 开启多个进程的时候,玩游戏的同时可以听音乐,他们并不是同时进行的,而是一点时间片在两个进程之间进行高效切换!

线程:

能够执行的最小单元!(一个线程可以看成进程的某个任务) 360软件---->开启---->开启进程 同时清理内存---同时查杀病毒

多线程的意义:

多个线程在互相抢占CPU执行权,线程的执行具有随机性!

jvm是多线程吗?

是一个多线程的,至少有两条线程 开启main线程---用户线程 gc----垃圾回收器 开启垃圾回收线程(回收没有更多的对象)

Java能够直接创建多线程吗?

创建线程---->需要创建进程---->需要使用系统资源创建进程 Java是不能够直接操作系统资源的,底层语記C是可以操作系统的 Jdk提供了Thread类,里面有个start()---->执行线程---底层非Java语言实现的

提供Thread类第一种创建线程的方式 1)自定义一个类继承的自Thread类 2)重写Thread类的run方法---->完成一些的耗时的操作 3)在main用户线程中,创建当前这个类对象 4)开启线程---->不是run方法,run方法它只是一个普通方法(仅仅执行线程里面的内容:读文件/完成io的操作...) 启动线程start()--->jvm是调用run线程的方法，结果是两个同时执行(具有随机性)

java. lang. IllegalThreadStateException非法线 程状态异常(一个线程不能启动多次)

Thread类提供一些基本功能:

public final void setName(String name):设置线程的名称 public final String getName():获取线程名称

优先级

public static final int MAX_PRIORITY 10最大优先级 public static final int MIN_PRIORITY 1最小优先级 public static final int NORM_ ,PRIORITY 5默认 优先级 优先级越大,线程抢占CPU执行权的几率越大!

给线程设置优先级

public final void setPriority(int newPriority)获取线程的优先级 public final int getPriority()

Java创建多线程方式

1)继承关系 Java提供的Thread类 2)实现关系 Runnable接口(方式2:使用Java设计模式之静态代理--设计模式之结构型设计模型的一种代理类/和被代理类都需要实现同一个接口)

线程的有几种状态

生命周期:就是线程从新建--->就绪--->执行---->死亡(终止)

 

线程的调度相关的方法

public final void join() throws InterruptedException 等待该线程终止

public static void yieLd():暂停当前正在执行的线程,执行其他线程

线程1,线程2,线程3,线程2在线程1的后面执行，线程3在线程2的后面执行---使用join()方法

线程的调度相关的方法

public final void join() throws InterruptedException 等待该线程终止

public static void yieLd():暂停当前正在执行的线程,执行其他线程

线程1,线程2,线程3,线程2在线程1的后面执行，线程3在线程2的后面执行---使用join()方法

线程的调度相关的方法

public final void join() throws InterruptedException 等待该线程终止

public static void yieLd():暂停当前正在执行的线程,执行其他线程

线程1,线程2,线程3,线程2在线程1的后面执行，线程3在线程2的后面执行---使用join()方法