Java语法随记

最新推荐文章于 2024-11-08 14:58:24 发布

似忆

最新推荐文章于 2024-11-08 14:58:24 发布

阅读量154

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_59159431/article/details/129558402

版权

java

1 字符

（1）判断字符大小及相等

a.equals(b); // 判断相等
a.equalsIgnoreCase(b);// 忽略大小写相等
a.compareTo(b);// i>0 a>b;判断大小
a.compareToIgnoreCase(b);// 忽略大小写比较

（2）字符串截断操作

s.substring(start,end)//第一个表示字符串起始位置，第二个表示结束位置(不包含)
eg:s.substring(start)；//截取到最后**
s.split(); //分解字符串，括号里填规则
s.trim(); // 去掉字符串的首尾空格

（3）字符串替换

s.replace(target,replacement);//替换
s.replaceAll(regex,replacement);// 按照指定规则替换,可以替换多个

（4）字符串大小写转换

s.toLowerCase();//小写
s.toUpperCase();//大写

（5）字符串查找

char[] chars=s.toCharArray();
s.getBytes("UTF-8");
s.charAt();//传递索引定位字符串中字符
s.indexOf("a");//查询第一回字符出现位置
s.lastIndexOf("a");//查询最后一回字符出现位置
s.contains("a");//是否包含指定字符
s.startsWith("a");//查询字符串是否以指定数据开头
s.endsWith("a");//查询字符串是否以指定数据结尾
s.isEmpty();//判断是否为空

（6）StringBuilder：构建字符串

StringBuilder s=new StringBuilder();
for(int i=0;i<100;i++){
s.append(i);
}
**效率比直接拼接高。**
还有其他用法，
s.reverse();//反转操作
s.insert(offset,str);//插入操作

2 包装类

// Byte、Short、Integer、Long、Float、Double、Character、Boolean
Integer i1= Integer.valueOf(i);//基本数据类型转换为包装类型；
Integer i1=i;//自动装箱
//int i2=i1.intValue();
int i2=i1;//自动拆箱

3时间类

//Data:日期类
System.currentTimeMillis(); //获取时间戳：毫秒
//Date:日期类 Calendar：日历类
Date d=new Date();
//java格式化日期格式：
//y(Y)->年-》yyyy
//m(M)->MM：月份，mm:分钟
//d(D)->dd:一个月日期，D：一年中日期
//h(H)->h:12进制，H：24进制
//s(S)->s:秒，S：毫秒/
// 日期转字符串
SimpleDateFormat sdf=new SimpleDateFormat(pattern："yyyy-MM-d HH:mm:ss.SSS"); 
String time=sdf.format(d);
//字符串转日期
String data="2022-06-21";
Date parseDate=sdf.parse(date);
//根据时间戳构建指定的日期对象
d.setTime();
//获取时间戳
d.getTime();
//判断时间先后
parseDate.before(d);

// 日历类
Calendar instance=Calendar.getInstance();
instance.get(Calendar.YEAR); //获取年份

4 工具类

不应创建对象才能使用，可以直接使用类中的属性和方法，一般声明为静态；
属性方法应该是公共的；
提供丰富的方法和属性；

//字符串工具类
//非空判断

5 比较

基础数据类型
==
引用数据类型
s.equals(s2)
对象：
重写父类Object方法equals
包装类型：
Integer缓存：-128~127超过则创建对象（==）
 用.equals();

6 集合

集合：数据的容器，容纳数据。
java提供了完整的集合框架，集合框架中包含了对不确定个数的数据处理的集合类。
在数据个数不确定的场合，数组用起来不方便。
对不确定的有关系的数据进行相同的逻辑处理的场合，使用集合是一个不错的选择。
根据数据不容，java集合分为两大体系
1.单一数据体系：Collection接口定义了相关的规则
2.成对出现的数据体系：Collection接口定义了相关的规则，称之为键值对数据。

（1）Collection接口
常用的子接口
List：按照插入顺序保存数据，数据可以重复
具体实现类：ArrayList、LinkedList
Set：无序保存，数据不能重复
具体实现类：HashSet
Quene：队列
具体实现类：ArrayBlockingQueue
（2）Map接口
具体实现类：HashMap、HashTable

1 List

(1)ArrayList

// ArrayList:Array+List
// List:列表、清单,按照数据插入顺序进行存储
// Array:数组，阵列
//创建集合对象：ArrayList
ArrayList list=new ArrayList();
// 1.不需要传递构造参数，直接new即可，底层数组为空数组
//2 .构造参数需要传递一个int类型的值，用于设定底层数组的长度
//3.构造参数传递一个Collection集合类型的值，将其他集合中数据放在当前集合中。
//增加数据
//add方法可以增加数据，只要将数组作为参数传递到add方法即可
 **添加数据时，底层会创建长度为10的数组**
list.add();
//访问集合中数据
// 获取集合中数据长度
list.size();
//获取指定位置的数据，可以采用索引的方式，底层为数组
list.get(index);
//遍历集合中的数据
for(int i=0;i<list.size();i++){
list.get(i);
}
// 如果循环遍历集合数组时，不关心数据的位置，采取特殊的for循环
//for(循环对象：集合)
for(Object obj:list){
	obj;
}
//修改数据:将指定位置数据修改,set方法需要传递2个参数，第一个
//参数表示数据位置，第二个表示参数修改的值，返回的是更新前值
list.set(1，"11");
//删除数据,返回删除的值
list.remove(1);

ArrayList的常用方法

//add可以传递两个参数，第一个表示数据增加的位置，第二个为数据
list.add(1,"s");
//判断集合中数据是否为空
list.isEmpty();
//清空集合中数据
list.clear();
//删除指定集合中的数据
list.removeAll();
//用于判断集合中是否包含某个数据，返回布尔类型
list.contains("s");
//用于获取数据在索引中第一个的位置，不存在返回-1
list.indexOf("s");
//用于获取数据在索引中最后一个的位置
list.lastIndexOf("s");
//集合转换为数组
Object[] objects=list.toArray();
//复制新集合
Object clone=list.clone();
ArrayList list1=(ArrayList)clone;

2 LinkedList

//LinkedList:Linked+List
//构建集合对象
LinkedList list=new LinkedList();
//增加第一个数据
list.add("s");
//获取第一个数据
list.getFirst();
//获取最后一个
list.getLast();
//插入到头
list.addFirst("b");
//插入到对应索引数据
list.add(index,data);
//获取数据（遍历数据)
list.get(1);
for(Object obj:list){
	obj
}
//修改数据
list.set(index,element);
//删除数据
list.remove(element);

LinkedList常用方法

list.removeFirst();
list.removeLast();
list.clear();
//获取第一个数据
list.elemment();
//添加数据
list.push();
//弹出数据
list.pop();

3 泛型语法

 ArrayList<Person> list=new ArrayList();

4 排序

//排序需要传递一个实现了比较器接口的对象
list.sort();
Class NumberComparator implements Comparator<Integer>{
@override
public int compare(Integer o1,Integer o2){
	return o1-o2;
}
}

5 ArrayList与LinkedList对比

增加第一条数据，LinkedList会比ArrayList快（ArrayList会由个创建的过程，扩容）。
增加第二条数据，ArrayList会比LinkedList快。
插入的话，LinkedList会比ArrayList快。
读取数据，有索引，ArrayList快，无，相同。

2 Set

1 Hashset

//HashSet:Hash+Set底层数组+链表
//Hash:哈希算法，散列算法,由于Hash算法，存储是无序的
HashSet set =new HashSet();
//增加数据
set.add();
//修改数据：不能修改，Hash算法定位不一样
//删除数据
set.remove();
//查询数据，得不到数据的索引，找不到数据的位置，只能遍历
for(Object o:set){
System.out.println(o);
}

//Set的方法
//集合变数组
set.toArray();
//集合清空
set.clear();
//是否包含
set.contains("s");

3 Queue(Collection)

// ArrayBlockingQueue:Array+Blocking(堵塞)+Queue
ArrayBlockingQueue queue=new ArrayBlockingQueue(capacity(容量));
//add方法增加不了数据，会报错
queue.add();
//put方法不会报错
queue.put();
//offer会返回一个布尔值
queue.offer();
// poll,取数据
queue.poll();
//take,拿数据,没有数据会处于阻塞状态
queue.take();

4 Map

1 HashMap

//HashMap：Hash+Map (数组+单向链表)
//数组存储无序
HashMap map=new HashMap();
//添加数据，也可修改数据，返回值是被修改的值
map.put(key,value);
//查询数据
map.get();
//删除数据
map.remove();

HashMap的常用方法

//添加数据、修改数据
map.put();
//添加数据，没有添加，有就不覆盖
map.putIfAbsent()
//替换，返回的是修改的值
map.replace();
//清空
map.clear();
//获取map集合中所有的key
map.keySet();
//判断是否有key
map.containsKey();
//获取values
Collection values=map.values();
//是否包含value
map.containsValue();
//获取键值对对象
HashMap<String,String> map=new HashMap();
Set<Map.Entry<String,String>> entries=map.entrySet();
for(Map.Entry<String,String> entry:entries){
	System.out.println(entry);
	System.out.println(entry.getKey());
	System.out.println(entry.getValue());
}
// remove(key,value),同时相同才删除
map.remove(key,value);

2 Hashtable

// Hashtable: 同步
Hashtable table = new Hashtable();
// 实现方式不一样：继承父类不一样
// 底层架构容量不同：HashMap(16),Hashtable(11)
// HashMap的K，V都可以为null，Hashtable中K、V不能为null
// HashMap的数据定位采用的是Hash算法，Hashtable采用的
// 就是hashcode
// HashMap的性能较高，但是Hashtable较低，同步关键字

3 迭代器

HashMap<String,Integer> map=new HashMap<String,Integer>();
Set<String> keys=map.keySet();
//迭代器
Iterator<String> iterator=keys.iterator();
//hasNext方法用于判断是否存在下一条数据
while(iterator.hasNext()){
	//获取下一条数据
	String key=iterator.next();
	map.get(key);
}

集合工具类

//集合Arrays
int[] is={1,2,3,4,5}
Arrays.toString(is); // [1,2,3,4,5]
is // 地址
List<Integer> integers=Arrays.asList(1,2,3,4,5);
//排序
Arrays.sort(is);
//二分查找法，排序后数组
Arrays.binarySearch(is,key);
//数组比较
Arrays.equals(is,is1);

7 数据流

// 数据+流（转）操作
// IO: I:input 输入（IN）
// O:output 输出（out）
// Stream :流传
// Java管道不是只有一个
// Java管道是不一样的

(1)文件流

// Java IO-文件流
// File:文件类型（文件、文件夹），属于Java.io
// 创建文件对象,使用文件路径关联系统文件
String filepath="";
File file=new File();
//文件对象的操作
// 判断文件对象是否为文件
file.isFile();
//判断文件对象是否为文件夹
file.isDirectory();
//判断文件对象是否存在关联
file.exists();
//创建多级文件目录
file.mkdirs();
//创建新文件
file.createNewFile();
//获取文件名称、大小、修改时间、绝对路径
file.getName();
file.length();
file.lastModified();
file.getAbsolutePath();
//获取文件夹名称
...
//目录底下文件
String[] list=file.list();
//返回文件对象
File[] files=file.listFiles();


// 文件复制
//文件输入流（管道对象）
FileInputStream in=new FileInputStream(srcFile);
//文件输出流（管道对象）
FileOutputStream out=new FileOutputStream(destFile);
//打开阀门，流转数据（输入） 输入一个就关闭
// 如果数据全部读取完再读取，读取结果为-1.表示无效
int data=in.read();
//打开阀门，流转数据（输出）
out.write(data);
//管道用完关闭
in.close();
out.close();

（2）缓冲流

//缓冲输入流（管道对象）
BufferedInputStream buffIn=new BufferedInputStream(in);
//缓冲输出流（管道对象）
BufferedOutputStream buffOut=new BufferedOutputStream(out);
//缓冲区
byte[] cache= new byte[1024];
//读取到缓冲区
data=buffIn.read(cache);

（3）字符流

// Unicode编码
//byte =>-128~127
// asc =>0~127
//字符输入流
BufferedReader reader =new BufferedReader(new FileReader(srcFile));
//字符输出流
PrintWriter writer =new PrintWriter(destFile);
//读取文件中一行数据
String line=null；
//读取一行
line=reader.readLine();

writer.println(line);
//刷写数据
writer.flush();

（4）序列化

//对象变为字节，序列化
//对象输出流
ObjectOutputStream objectOut=null;
FileOutputStrean out=null;
out =new FileOutputStream(dataFile);
objectOut=new ObjectOutputStream(out);
//java中只有增加了特殊的标记的类，才能在写文件时进行序列化操作
//这里的标记其实就是一个接口 implements Serializable
User user=new User();
objectOut.writeObject(user);
objectOut.flush();
//从文件中读取数据转换成对象
//对象输入流
FileInputStream in=new FileInputStream(src);
objectIn=new ObjectInputStream(in);
Object o=objectIn.readObject();

总结

8 线程

jps 展示java进程 cmd指令
进程，正在运行的程序

// Thread是线程类
// currentThread 方法用于获取当前正在进行的线程
// getName 获取线程名称

Thread.currentThread().getName();
// 创建线程
Thread t=new Thread();
// 启动线程
t.start();
// 执行方式（串行，并行）
// 串行执行：多个线程连接成串，然后按照顺序执行
//并发执行：多个线程是独立，谁抢到CPU执行权，谁就先。
// 线程连接成串
t1.join();
t2.join(); 
// 声明自定义线程类
Class MyThread extends Thread{
   public void run(){
   
   }
}

// 线程休眠 
// 休眠3s
Thread.sleep(3000);

// 自定义线程
// 1.继承线程类(父类)
// 2.重写run方法
class MyThread3 extends Thread{
	@override
	public void run(){
   
}

// 线程手动命名
class MyThread4 extends Thread{
	private String threadName;
	public MyThread4(String name){
   threadName =name;
}
	@override
	public void run(){
   
}
}
// 构建线程对象时，可以只把逻辑传递给这个对象
// 传递逻辑时，需要遵守规则：（）->{ 逻辑}
Thread t6=new Thread() ->{
System.out.println("线程执行")；
}
// 构建线程对象时，可以传递实现了Runnable接口的类的对象,一般使用匿名类
Thread t8 = new Thread(new Runable()){

}

// 线程池
// 所谓的线程池，就是线程对象的容器
// 可以根据需要，在启动时，创建一个或多个线程对象
//java有4种比较常见的线程池
// 1.创建固定数量的线程对象
// ExecutorService:线程服务对象
ExecutorService executorService = Executors.newFixedThreadPool(3);
executorService.submit(new Runnable()){

}
// 2、根据需求动态创建线程
ExecutorService executorService =Executors.newCachedThreadPool();
//3 .单一线程
ExecutorService executorService =Executors.newSingleThreadExecutor();
//4 .定时调度线程
ExecutorService executorService =Executors.newScheduledThreadPool(3);

//同步
// synchronized:同步关键字
// 多个线程访问同步方法时，只能一个一个访问，同步操作
// object.notifyAll();执行该方法，会唤醒所有被wait()阻塞线程
// object.wait(); 线程等待
// synchronized关键字还可以修饰代码块，称之为同步代码块
/*
synchronized(用于同步的对象){
	处理逻辑
}
*/
Class User {
	public synchronized void test(){
	}
}

// 阻塞
// wait & sleep
// 1.名字
//     wait :等待
//     sleep:休眠
// 2.从属关系
// 		wait:Object,成员方法
// 		sleep:Thread，静态方法
// 3.使用方式
//		wait:只能使用在同步代码中
// 		sleep:可以在任意地方使用
//4.阻塞时间
//		wait:超时时间（会发生错误）
// 		sleep:休眠时间（不会发生错误）
//5.同步处理
//		wait:如果执行wait方法，那么其他线程有机会执行当前的同步操作
//		sleep:如果执行sleep，其他线程没有机会会执行当前的同步操作

//线程安全
// 所谓的线程安全问题，其实就是多个线程在并发执行时，修改了共享内存中共享对象的属性，导致数据冲突问题，栈内存独享，堆内存共享
// java会对每一个线程创建一个栈内存。

9 反射

// 反射
// 类对象

Class<? extends User> aClass=user.getClass();
// 获取类的名称
aClass.getName();// 获取类的完整名称(包含包名)
aClass.getSimpleName(); //获取类名称
aClass.getPackageName(); // 获取类的包的名称

// 获取类的父类
Class<?> superclass=aClass.getSuperclass();
// 获取类的接口
Class<?>[] interfaces=aClass.getInterfaces();
// 获取类的属性
Field x=aClass.getField("x") //public
Field x=aClass.getDeclaredField("x") // 所有权限
Field[] fields=aClass.getFields(); 
Field[] x=aClass.getDeclaredFields("x")
// 获取类的方法
Method method=aClass.getMethod("xxx"); //public
Method method=aClass.getDeclaredMethod("xxx"); //所有权限
//构造方法
Constructor<? extends User> constructor=aClass.getConstructor();
Constructor<?>[] constructors=aClass.getConstructors();
aClass.getDeclaredConstructors();
// 获取权限(修饰符):多个修饰符会融合成一个int值
int modifiers=aClass.getModifiers();
boolean aPrivate=Modifier.isPrivate(modifiers);

// 类加载器
//加载类
// java中类分为三种
// 1.Java核心库中的类：String、Object
// 2.JVM软件平台开发商
// 3.自己写的类，User，Child
// 类加载器也有三种
// 1.BootClassLoader:启动类加载器(加载类时，采用操作系统平台语言实现)
// 2.PlatformClassLoader：平台类加载器
// 3.AppClassLoader：应用类加载器

// 获取类的信息
Class<Student> studentClass=Student.class;
// 获取类的加载器对象
ClassLoader classloader = studentClass.getClassLoader;
// 加载Java核心类库 > 平台类库 > 自己类