11_4-11_9周总结

最新推荐文章于 2024-09-15 19:46:31 发布

中向阳光

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量181

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/yz20221022/article/details/127935646

版权

11_4

1.常用类之Object

int hashcode():哈希码值(理解为"地址值",并非实际地址值) 了解
String toString():返回对象的字符串表示形式,结果应该是一个更容易让人读懂的信息表达式(建议所有的子类都覆盖这个方法) 几乎Java所有类都会重写toString()方法

boolean equals(Object obj):指定其他对象与此对象是"相等"

==和equals()方法区别?

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

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

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

重写equals:比较每一个对象的成员信息是否相同,如果一样,还要比较每一个成员信息hashCode()哈希码值是否一样,如果都相同,系统认为这个两个人是一样的!

clone():克隆

protected Object clone() throws CloneNotSupportedException 创建对象并返回它的"副本"

方法里面本身就会带有CloneNotSupportedException:克隆不支持的异常(当要对某个Object的类进行克隆,如果这个类不能实现cloneable接口,那么就会出现这个异常)

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

public boolean hasNextInt():判断录入的下一个数据是否为int类型,是,返回true,否则false

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

键盘录入的时候先录入int,在录入String ----nextLine() ,这块会出现被漏掉("回车符号")

解决方案:

1)在第一个录入int之后,重新创建一个新的键盘录入对象Scanner ,然后再使用nextLine()

2)再录入String---- String next()

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

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 offseet,int len):将一部分字符串数组构造成字符串

面试题:

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

数组:没有length(),length属性但是可以数组对象.length

字符串有length()

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

面试题:

String s = new String("hello") ;

和String s = "hello" ; 有什么区别?分别创建了几个对象?

区别

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

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

String类相关的获取功能

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

2)int length():获取字符串的长度

3)public String concat(String str)拼接功能-- 将一个字符串拼接到指定字符串的后面(末尾追加) 4)public String substring(int beginIndex):截取--->从指定位置开始截取,默认截取到末尾结束! * public String substring(int beginIndex, int endIndex) 截取--->从指定位置开始截取到指定位置结束包前不包后(包含第一个位置,不包含最后一个位置,只能取到endIndex-1处)

5)public String[] split(String regex):拆分(分割) ,按照指定的分割符将字符串拆分成字符串数组 * 6)public int indexOf(int ch) :返回此字符第一次在字符串中出现的索引值

public int lastIndexOf(int ch):返回此字符最后一次在字符串中出现的索引值

String类的转换功能

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

2)byte[] getBytes() 平台默认字符集编码(String--->byte[])

byte[] getBytes(String charset):指定的字符集进行编码

String(byte[] bytes) :(bytes[]--->String ) 平台默认字符集解码

String(byte[] bytes,String charset) :(bytes[]--->String ) 指定字符集解码

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

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

4)万能方法: 可以将任何数据类型---->String

public static String valueOf(int i/float....Object)

编码和解码必须一致,否则乱码!

concat的用法 + substring()+转换功能---

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

1)可以录入字符串 s1

2)将字符串的一个字符截取出来 s2

substring(0,1) -->"H"----->转换小写 toLowerCase()

3) s1字符串 subString(1) ----> "ellowold"--->转换成大写 toUpperCase() --->s3

2)和3)结果----->concat拼接功能----->结果s4

5) 输出

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

boolean contains(String str):判断大串中是否包含指定子字符串

boolean endsWith(String suffix):判断是否以指定结尾的字符串

public boolean startsWith(String prefix):判断是否指定的字符串开头

boolean equals(Object anObject)。:比较两个字符串内容是否相同

boolean equalsIgnoreCase(String anotherString) :不区分大小写比较两个字符串是否相同

public boolean isEmpty():判断字符串是否空 ,长度为0,true

public String replace(char oldChar,char newChar) :替换功能

public String trim() :去除字符串两端空格 (一般io流中: 文件读写文件)

面试题

String s1 = "hello"; * String s2 = "hel" ;

按照字典顺序比较,它的结果是多少? 考察的就是compareTo的源码 public int compareTo(String anotherString):两个字符串按照字典顺序比较!

两个字符串进行字典顺序比较,先算出长度,取出最小值,然后比较每一个字符,如果这俩个字符串的第一个字符都不相同 , 使用前面的字符和后面的的字符进行相减(ASII码表的值相减)

如果长度的最小值,在循环遍历两个字符串的每一个字符之前,都相同,直接是两个字符串长度相减!

+字符串拼接符号 ----->

""+10

concat(String str) 这两种哪一个高效?

+拼接符号更高效一些

String s = null ;

s.concat("hello") ; 左边不能为空对象,如果这样导致NullPointerException:空指针

11_5

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

StringBuffer:线程安全的类,支持可变字符序列!

线程-->依赖于进程,线程执行的最小单元!

线程安全----->意味着 "同步"---->执行效率低

举例: 银行类的网站/医院平台

线程不安全----> "不同步"---->执行效率高

举例: 论坛网站

构造方法:

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

public StringBuffer(int capacity)--->指定容量大小的字符串字符串缓冲区(很少用)

public StringBuffer(String str)--->将指定的字符串内容构造到字符串缓冲区中,容量=当前str的长度+16

int length()获取字符串缓冲区长度

int capacity() :获取容量大小

StringBuffer的追加和插入

public StringBuffer append(任意Java类型):将指定的类型追加字符串缓冲区的序列中,返回自己本身 public StringBuffer insert(int index,String str/可以任意Java类型) 在指定位置处插入指定的数据,返回字符串缓冲区本身

StringBuufer的获取功能

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

StringBuffer的删除

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

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

StringBuffer的替换功能:

public StringBuffer replace(int start,int end,String str)

将字符串缓冲区中的从指定位置开始到指定位置结束(end-1)的字符序列使用指定的字符串进行替换

StringBuffer的截取功能:

public String substring(int beginIndex)

public String substring(int beginIndex,int endIndex)

StringBuffer的特有功能:

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

在实际开发中,牵扯很多类型之间的相互转换

将A类型-->B类型,因为想去使用B类型的功能

但是又可能将B类型--->A类型,最终需求的结果是A类型

String---->StringBuffer

方式1 :使用StringBuffer(String str)有参构造

方式2:使用StringBuffer()空参构造,结合append(String str)追加

StringBuffer---->String

方式1:StringBuffer--->public String toString()

方式2:String类----->构造方法public String(StringBuffer buffer)

String和StringBuffer/StringBuilder的区别?

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

作为形式参数,形式参数的改变不影响实际参数(和基本类型作为形式参数传递的效果一致 ,特殊的引用类型)

StringBuffer:支持可变的字符串序列磊,线程安全的类--->同步的--->执行效率低

StringBuffer的大部分功能--->synchronzied:同步锁(悲观锁)

作为形式参数,形式参数的改变直接影响实际参数

StringBuilder:和StringBuffer具备相互兼容的API,线程不安全的类---不同步的---->执行效率高

单线程程序(只考虑效率)中,使用StringBuilder去替代StringBuffer

多线程环境下(要考虑安全),使用StringBuffer

2.Integer

Integer类:包装的int类型的值

四类八种基本类型---------->包装类类型(引用类型) :jdk5以后的自动拆装箱

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

基本类型引用类型 String

String Integer int

Integer的构造方法:

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

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

jdk5以后的新特性:自动拆装箱 /静态导入(导入到方法的级别,前提方法必须为静态)/增强for循环/可变参数...

基本类型会自动装箱为引用类型: int-->Integer

引用类型会拆箱为基本类型 : Integer-->int

类型转换

int---->String 静态方法public static String toString(int i)

方式1:字符串拼接符号+

方式2:int--->Integer---->String

方式3:Integer的静态方法public static String toString(int i)

String--->int (使用居多) public static int parseInt(String s)

前后端交互:前端提交的数据几乎String类型

方式1:String--->Integer --->public int intValue()

方式2:直接转换public static int parseInt(String s) throws NumberFormatException

parseXXX方法在任意的基本类型对应的类型都存在(万能方法)

String--Long-->long---->Long.parseLong(字符串)

String--Float-->float--->Float.parseFloat(小数字符串)

看程序,写结果

Integer 对象名 = 整数值; ---->执行底层的Integer.valueOf(整数值)---->

IntegerCache静态的成员内部类(内部缓存区)---->low (-128)/high(127)

如果整数值在-128-127之间,直接从IntegerCachec里面的cache[]里面取值

如果超出范围内, new Integer(整数值); 重新创建Integer类对象,堆内存开辟空间

3.Character

构造方法

Character(char value):包装一个char字符类型 char---->Character

成员方法

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

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

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

4.java.util.Date:特定的日期

构造方法:

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

成员方法:

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

Date日期格式 ----->String日期文本 --->格式化操作

public class DateUtils {
    private DateUtils(){}

public static String date2String(Date date,String pattern){

    return new SimpleDateFormat(pattern).format(date) ;
}

public static Date string2Date(String source,String pattern) throws ParseException {

        return  new SimpleDateFormat(pattern).parse(source) ;
    }
}

5.Random

Random:伪随机数生成器

public Random() 构造方法:创建新的随机数生成器

public Random(long seed) 构造方法:创建新的随机数生成器(以指定的long 的类型计算随机数):每一次均分布局一样的 (不推荐)

成员方法

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

public int nextInt(int n):[0,n)随机数

6.System类: 不能实例化

三个成员变量 ---静态常量

static PrintStream err“标准”错误输出流。

static InputStream in“标准”输入流。 (InputStream:字节输入流 --读数据)

static PrintStream out “标准”输出流。(PrintStream字节打印流---> * OutputStream字节输出流---写/打印)

成员方法

public static long currentTimeMillis():获取系统时间毫秒值(应用场景:计算程序的执行效率)

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

public static void gc():手动开启垃圾回收器

开启垃圾回收器,会调用Object类的finalize()垃圾回收方法

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

参数1:原数组

参数2:原数组中的某个位置

参数3:目标数组

参数4:目标数组中的某个位置

参数5:从原数组的那个位置srcPos指定长度复制到目标数组中

11_16

1.其他类之Calendar日历类/BigDecimal:小数精确计算

java.util.Calendar :日历类--->是一个抽象类,不能new

这个类里面的某些功能(静态功能)---一定完了这个类的子类的实例!

创建日历实例--->public static Calendar getInstance()

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

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

public static final int MONTH:年中的月份值 (0-11),获取之后+1

public static final int YEAR:年份值

Calendar提供成员方法:

public int get(int field):获取日历的字段值

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

public abstract void add(int field,int amount) 给日历字段设置偏移量,添加或者减去amount值

public final void set(int year,int month,int date) 设置日历字段

BigDecimal:作用针对小数进行精确计算构造方法

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

BigDecimal(int value):整数

BigDecimal(double value):浮动类型

成员方法:

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)

参数1:除数值

参数2:scale保留小数位数

参数3:roundingMode舍入的模式 BigDecimal提供静态常量

2.Jdk5里面其他新特性:

1)静态导入---->导入到方法的级别

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

前提使用静态导入,这个类的方法必须为静态

在使用静态导入的时候,导入jdk提供的一些工具类里面静态方法的时候,我们定义的方法不能和它方法名冲突

如果冲突了,静态导入是不识别,这个时候必须导入全限定名称 :包名.类名.方法名(xxx)没有jdk提供直接实现,通过具体的子接口List/Set的子实现类实现

2)可变参数,当一个方法形式参数不知道多少个,这个时候可以使用可变参数(类似一个数组)

public 返回值类型方法名(数据类型... 参数名)

3.Collection

Colleciton:没有jdk提供直接实现,通过具体的子接口List/Set的子实现类实现

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

模拟数组,创建集合的时候就明确了集合中存储的数据类型,否则导致程序不安全!

常用基本功能:

添加 boolean add(E e):添加元素 E--->Object任意Java元素

删除删除集合中的元素boolean remove(Object o)

暴力删除(将集合全部清空)void clear()

判断 boolean isEmpty():判断集合是否为空

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

遍历

1)将集合转换对象数组

Object[] toArray() 不推荐,还是变成数组!

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

Iterator<E> iterator()

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

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

需求:使用Collection存储String类型,并去使用迭代器将元素一一遍历,打印控制台

1)使用Collection集合存储5个学生,使用迭代器的这种方式进行遍历!

2)使用Collection集合存储String类型,如果这个字符串是"world",那么添加一个新的字符串数据"javaEE", 然后遍历集合中的数据

使用Collection集合存储String类型,如果这个字符串是"world",那么添加一个新的字符串数据"javaEE", 然后遍历集合中的数据

分析:

存储"hello","world","java"

使用迭代器遍历集合

获取元素---如果这个元素和"world"一致,给集合中添加"javaEE"

按照上面的分析完成代码实现出现下面错误

java.util.ConcurrentModificationException:并发修改异常

并发:某个时间点

并行:某个时间段

出现并发修改异常的原因:当使用迭代器去遍历元素的时候,不能同时在使用集合操作元素;解决方案: 1)使用迭代器遍历,迭代器添加,但是现在Collection的迭代器没有添加功能----->List集合的特有列表迭代器ListIterator

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

List集合E get(int index)

for(int x= 0 ;x < list集合对象.size();x++){

String s = list集合对象.get(x) ;

if("world").equals(s){

list集合对象.add("javaee");

}

4.List

List集合的特点

允许集合元素重复(实际应用,List集合如何去重?),而且有序集合(存储和取出一致)

List集合的特有功能:

void add(int index, E element):在指定位置插入新的元素

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

E set(int index,E element):在指定位置处替换(修改)指定的元素

ListIterator<E> listIterator():List集合的专有遍历-->列表迭代器

11_17

1.List去重

1)创建一个集合

2)添加重复的String

3)新建一个集合

4)遍历以前的集合

5)遍历新集合

或者使用选择排序的思想

2.Vector和LinkedList的特有功能

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

特有功能:

public void addElement(E obj)将指定的元素添加Vector集合中(默认追加)

public Enumeration<E> elements():获取枚举组件接口----->类似于Collection集合的Iterator iterator()

Enumeration接口

boolean hasMoreElements() 判断是否有更多的元素 ----->类似于Iterator里面的boolean hasNext() E nextElement() :获取下一个元素 ----->类似于Iterator里面的E next()

public E elementAt(int index):通过索引值获取元素 ---->类似List集合的E get(int index) * int size():获取集合元素数

LinkedList: 线程不安全,不同步,执行效率高

底层数据结构: 线程结构之链表,查询慢,增删快!

特有功能:

添加元素

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

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

public E getFirst():获取第一个元素 * public E getLast():获取最后一个元素

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

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

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

Set集合:元素唯一的默认情况使用HashSet进行实例(创建对象)

HashSet的底层依赖于HashMap(哈希表结构),元素唯一,迭代顺序无法保证的!

HashSet集合保证元素唯一---底层依赖HashMap的put方法---->依赖于hashCode()/equals(), 而现在存储String类型,重写了equals和hashCode(),保证元素唯一!

TreeSet集合--->Set集合的的实现类,它应该满足保证元素唯一

底层基于TreeMap<K,V>,它是一个红黑树(red-black-tree)

有自然排序/比较器排序

构造方法:

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

现在使用TreeSet存储Integer类型的元素

结论:

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

TreeSet<Stdudent>,使用TreeSet存储自定义类型

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

compare实现了Comparator接口，compareTo实现了compareable接口。它们可以给对象和基本类型进行排序。给基本类型排序可以直接调用Arrays.sort()和Conllections.sort()方法直接排序，默认是升序的。降序和对象排序需要重写相应的方法。

11_18

1.TreeSet集合存储自定义类型如何实现自然排序和比较器排序

TreeSet基于TreeMap红黑树结构,存储第一个元素---根节点,后面的元素依次和根节点比较
小了,左子节点
大了,右子节点
相等,存以前的值

自然排序(默认使用的这种:大部分常用String/Integer/Character 都实现Comparable)
   TreeSet<自定义类型>,如果要实现自然排序,使用TreeSet的无参构造方法 public TreeSet<E>()
    自定义类型必须实现一个接口:Comparable<T>--->实现public int compareTo(T t){排序规则...}比较器排序
   TreeSet<E>(Comparator<T> com):有参构造方法
   方式1:自定义一个类实现Comparator接口---实现 public int compare(T t1,T t2){排序规则...}
   方式2:使用接口的匿名内部类
   TreeSet<自定义类型> ts = new TreeSet<>(new Comparator<自定义类型>(){
public int compare(自定义类型 t1,自定义类型 t2){排序规则...}
   }) ;

2.Map

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

Key Value ---->散列表结构(哈希表)

1 张三

2 李四

3 王五

4 张三

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(Object key):删除键,返回键对应的值

void clear():暴力删除,将map清空掉

判断:

boolean containsKey(Object key):判断Map集合是否包含指定的键,包含返回true,否则false

boolean containsValue(Object value):判断Map集合是否包含指定的值,包含则返回true,否则false

boolean isEmpty() :判断集合是否为空

遍历Map集合的方式

1)获取所有的键的集合 Set<K> keySet() (通用的遍历方式) --->"获取所有的丈夫",丈夫自己妻子 * 结合 V get(Object key):通过键找值

2)Set<Map.Entry<K,V>> entrySet() :获取Map结合的键值对对象 ---->"获取所有结婚",找丈夫,找妻子

HashMap---->put方法---->依赖于hashCode()+equals()方法能够保证键唯一!

存储String,String类型重写了hashCode()+equals()方法,比较键的字符串内容是否相同!

HashMap<K,V> 存储键值对元素,保证K唯一,根据的类型有关系

如果K是自定义类型,

HashMap<Student,String> ,考虑保证学生对象唯一!

Key:Student类型

Value:String类型

要针对键有效,需要键的类型,需要重写equals()和hashCode()

equals():比较内容是否相同, hashCode():比较每一个成员信息的哈希码值是否一样

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

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

常用的方法

二分搜索法,在指定List集合中查询指定元素第一次出现索引值 (集合的元素有序)

public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)

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

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

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

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

public static <T extends Comparable<? super T>> void sort(List<T> list):针对List集合按照自然顺序排序

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

11_19

线程依赖于进程存在!

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

多进程:计算机都是支持多进程,提高CPU的使用率!

开启多个进程的时候,玩游戏的同时可以听音乐,他们并不是同时进行的,而是一点时间片在两个进程之间进行高效切换!

线程: 能够执行的最小单元!(一个线程可以看成进程的某个任务)

360软件---->开启---->开启进程

同时清理内存---同时查杀病毒

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

1v3打篮球,3个人抢占篮球几率大,不一定(线程执行的是一个随机的)

JVM是多线程的吗?

是一个多线程的,至少有两条线程

main线程----用户线程

gc----->垃圾回收器开启垃圾回收线程(回收没有更多的对象!)

public static void main(String[] args){ //用户线程(主线程)

new Object();

new Object(); }

2.面试题: Java能够直接创建多线程吗?

创建线程---->需要创建进程---->需要使用系统资源创建进程

Java是不能够直接操作系统资源的,底层语言C是可以操作系统的

Jdk提供了Thread类,里面有个start()---->执行线程---底层非Java语言实现的

提供Thread类第一种创建线程的方式

1)自定义一个类继承的自Thread类

2)重写Thread类的run方法---->完成一些的耗时的操作

3)在main用户线程中,创建当前这个类对象

4)开启线程---->不是run方法,run方法它只是一个普通方法(仅仅执行线程里面的内容:读文件/完成io的操作....)

启动线程start()--->jvm是调用run线程的方法,结果是两个同时执行(具有随机性)

启动线程,想知道哪一个线程执行数据---Thread类提供一些基本功能:

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

public final String getName():获取线程名称

public final void join() throws InterruptedException 等待该线程终止

线程的优先级:

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()

public static void yield():暂停当前正在执行的线程,执行其他线程

中向阳光

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫