nextXXX():获取功能
public int nextInt() :录入int类型
public String nextLine() ;录入String类型
判断功能:
public boolean hasNextInt():判断录入的下一个数据是否为int类型,是,返回true,否则false
public boolean hasNextLine():判断录入的下一个数据为一行内容
键盘录入的时候
先录入int,在录入String ----nextLine() ,这块会出现被漏掉("回车符号")
解决方案:
1)在第一个录入int之后,重新创建一个新的键盘录入对象Scanner ,然后在使用nextLine()
2)在录入String---- String next()
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()方法,
集合没有,获取集合中 元素数 size()方法
获取功能
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)
编码和解码必须一致,否则乱码!
判断功能:
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流中: 文件读写文件)
* 按照字典顺序比较,它的结果是多少? 考察的就是compareTo的源码
* public int compareTo(String anotherString):两个字符串按照字典顺序比较!
*
* 两个字符串进行字典顺序比较,先算出长度,取出最小值,然后比较每一个字符,如果这俩个字符串的第一个字符都不相同
* 使用前面的字符和后面的的字符进行相减(ASII码表的值相减)
* 如果长度的最小值,在循环遍历两个字符串的每一个字符之前,都相同,直接是两个字符串长度相减!
* concat(String str) 这两种哪一个高效? +拼接符号更高效一些
* String s = null ;
* s.concat("hello") ; 左边不能为空对象,如果这样导致NullPointerException:空指针
Integer/Character
byte --- Byte
short --- Short
int --- Integer
long --- Long
float --- Float
double --- Double
char --- Character
boolean --- Boolean
String --- Integer --- int Integer.parseInt(数字字符串)
String --- Long ---long Long.parseLong(String数据)
String --- Float --- float Float.parseFloat("小数字符串")
StringBuffer类(字符串缓冲区,线程安全类)/StringBuilder
构造方法:
StringBuffer :
public StringBuffer()构造一个没有字符的字符串构建器,初始容量为16个字符。
StringBuilder(String str) 构造一个初始化为指定字符串内容的字符串构建器。
int length()获取字符串缓冲区长度
int capacity():获取容量大小
功能:
追加
public StringBuffer append()(任意java类型)将指定类型追加字符缓冲区的序列中,返回字符串本身
StringBuffer insert(int offest,String str/可以任何java类型)在此前面插入指定数据,返回字符串本身
获取:
public char charAt(int index)获取字符串缓冲区中指定位置的字符,返回指定的字符
删除:
StringBuffer delete(int start, int end) :删除从指定位置开始到指定位置结束(end-1)的字符,返回字符串缓冲区本身
StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回值字符串缓冲区本身
替换:
public StringBuffer replace(int start,int end,String str)将字符串缓冲区中的从指定位置开始到指定位置结束(end-1)的字符序列使用指定的字符串进行替换
截取:
public String substring(int beginIndex)
public String substring(int beginIndex,int endIndex)
反转:(特有功能)
public StringBuffer reverse() 将字符串缓冲区的字符序列进行反转
类型转换:
StringBuffer ---> String
String s = "hello" ;
方式一:
创建字符缓冲区:
StringBuffer s = new StringBuffer();//空参 追加
s.append();
方式二:
StringBuffer s = new StringBuffer(String);//有参
String ---> StringBuffer
StringBuffer buffer = new StringBuffer("helloJavaEE") ;
方式一:
转换成String
String str = buffer.toString();
方式二:
有参构造
String str2 = new String(buffer) ;
java.util.Date:特定的日期
构造方法:
public Date():系统时间的日期格式
成员方法:
public long getTime():获取指定Date对象的系统时间毫秒值
Date日期个--->String格式化
public final String format(Date date)
构造方法
SimpleDateFormat(String pattern)
pattern模式:
y:代表年 yyyy 代表整个年份 :2022
M:代表月份 MM 11 07 06
d:月份中的日 dd 03 11 01
H:0-23(一天的小数数) HH
m:小时的分钟数 mm
String日期文本---->Date 解析
public Date parse(String source) throws ParseException :
如果String日期文本 和转换器SimpleDateFormat(String pattern) 里面的模式不匹配就会造成解析异常!
String s = "2008-5-12"
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd ") ;//解析出问题了!
Random:伪随机数生成器
public Random() 构造方法:创建新的随机数生成器
public Random(long seed) 构造方法:创建新的随机数生成器(以指定的long 的类型计算随机数):每一次均分布局一样的 (不推荐)
成员方法:
public int nextInt():获取的int类型的取值范围
public int nextInt(int n):[0,n)随机数
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指定长度复制到目标数组中
支持可变的长度—“集合”(开发中使用最频繁的)
只能存储引用类型Collection<泛型>
集合的结构体系
集合的通用功能
Integer
jdk5 以后的新特性:自动拆装箱
基本类型会自动装箱为引用类型:int-->Integer
引用类型会拆箱为基本类型:Integer-->int
public Integer(int value) :将int类型数据包装为Integer类型
public Integer(String s)throws NumberFormatException :将字符串类型包装Integer类型,如果字符串非数字字符串,就会出现NumberFormatExceptio数字格式化异常
类型转换
int---->String 静态方法Integer中 public static String toString(int i)
String--->int (使用居多)Integer中 public static int parseInt(String s)
前后端交互:前端提交的数据几乎String类型
Integer
控制台打印int类型的取值范围
int--->Integer---->静态的常量
public static final int MAX_VALUE
public static final int MIN_VALUE
/* public static String toBinaryString(int i):将十进制--转换二进制的字符串形式
public static String toHexString(int i)将十进制--转换十六进制的字符串形式
public static String toOctalString(int i)将十进制--转换八进制的字符串形式*/
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提供静态常量
publicclassCollectionTest2{publicstaticvoidmain(String[] args){//创建Collection// Collection<String> c = new ArrayList<>() ;//使用List集合List<String> c =newArrayList<>();///添加数据
c.add("hello");
c.add("world");
c.add("java");//获取迭代器// Iterator<String> it = c.iterator();//获取List列表迭代器//ListIterator<String> it = c.listIterator(); //List的迭代器遍历//遍历迭代器/* while(it.hasNext()){//迭代器的元素来自于集 合
//获取
String s = it.next() ;
//加入判断
if("world".equals(s)){//如果迭代器中的元素是world,使用集合给里面添加元素
//给集合添加"javaEE"
//c.add("javaEE") ;
//列表迭代器里面就是add方法:插入元素 (在指定元素的后面插入)
it.add("javaee");
}
System.out.println(s+"---"+s.length());
}
Iterator<String> it2 = c.iterator();
while(it2.hasNext()){
System.out.println(it2.next());
}*///优化代码//解决方案2:集合遍历,集合添加List集合的普通forfor(int x =0; x < c.size(); x++){//获取元素String s = c.get(x);if("world".equals(s)){
c.add("javaEE");}}//遍历元素for(String s:c){System.out.println(s);}}}
List<String> list =newArrayList<>();
list.add("hello");
list.add("world");
list.add("java");
list.add("javaEE");System.out.println("--------ListIterator迭代器-------");ListIterator<String> listIterator = list.listIterator();while(listIterator.hasNext()){String s = listIterator.next();if("hello".equals(s)){
listIterator.add("Spring");}}for(String a:list){System.out.println(a);}
Vector集合
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集合
如果需求 大量 "写"的操作,采用LinkedList
大量"读"的操作,默认使用ArrayList,大量"读",考虑线程 使用Vector
线程不安全,不同步,执行效率高
底层数据结构: 线程结构之链表,查询慢,增删快!
特有功能:
添加元素
public void addFirst(E e) 将指定的元素添加到链表的开头
public void addLast(E e) 将指定的元素添加到链表的末尾
public E getFirst():获取第一个元素
public E getLast():获取最后一个元素
public E removeFirst():删除第一个并返回第一个元素
public E removeLast():删除最后一个元素并返回
TreeSet集合的自然排序 实现Comparable接口
package com.stu.compartable;
import java.util.Objects;
/**
* @author xiaolin
* @version 2021.1
* @date 2022/11/17 10:28
*/
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && name.equals(student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student s) {
int a = this.name.length()-s.name.length();
int b= (a==0)?(this.name.compareTo(s.name)):a;
int c = (b==0)?(this.age-s.age):b;
return c;
}
}public class TreeSetTest {
public static void main(String[] args) {
TreeSet<Student> ts = new TreeSet<>();
Student s1 = new Student("dianwei",35);
Student s2 = new Student("dain",35);
Student s3 = new Student("dian",35);
Student s4 = new Student("zhang",36);
Student s5 = new Student("zhangg",35);
Student s6 = new Student("wa",45);
Student s7 = new Student("zhangg",46);
Student s8 = new Student("zhangg",20);
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
ts.add(s6);
ts.add(s7);
ts.add(s8);
for (Student s:ts){
System.out.println(s.getName()+"--"+s.getAge());
}
}
}
public class TreeSetTest {
public static void main(String[] args) {
TreeSet<Student> ts = new TreeSet<>();
Student s1 = new Student("dianwei",35);
Student s2 = new Student("dain",35);
Student s3 = new Student("dian",35);
Student s4 = new Student("zhang",36);
Student s5 = new Student("zhangg",35);
Student s6 = new Student("wa",45);
Student s7 = new Student("zhangg",46);
Student s8 = new Student("zhangg",20);
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
ts.add(s6);
ts.add(s7);
ts.add(s8);
for (Student s:ts){
System.out.println(s.getName()+"--"+s.getAge());
}
}
}
TreeSet集合的比较强排序–>Comparator接口匿名内部类
方式1:自定义一个类 实现Comparator接口---实现 public int compare(T t1,T t2){排序规则...}
方式2:使用接口的匿名内部类
TreeSet<自定义类型> ts = new TreeSet<>(new Comparator<自定义类型>(){
public int compare(自定义类型 t1,自定义类型 t2){排序规则...}
}) ;
常用的方法
二分搜索法,在指定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集合按照比较器进行排序
线程
提供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 static void yield():暂停当前正在执行的线程,执行其他线程
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()