JavaSE基础

最新推荐文章于 2022-04-08 20:52:06 发布

程序栾

最新推荐文章于 2022-04-08 20:52:06 发布

阅读量140

点赞数

分类专栏：笔记文章标签： javase

本文链接：https://blog.csdn.net/qq_42428900/article/details/120578681

版权

笔记专栏收录该内容

15 篇文章 0 订阅

订阅专栏

JAVA基础

1、常用类

*StringBuffer

StringBuffer sb = new StringBuffer();//创建一个对象，无初始值
StringBuffer sb = new StringBuffer("abc");//创建一个对象，有初始值为“abc”
StringBuffer sb = new StringBuffer(30);//创建一个对象，初始容量为30

sb.append(obj);//将obj追加到sb中，obj可为任何类型
sb.setCharAt(int index,char ch);//将索引处的字符修改为ch
sb.insert(int offset,String str);//将字符串str插入到索引处
sb.delete(int start,int end);//移除str的子字符串中的字符
sb.toString();//将sb转换为String类型

//同时StringBuffer类也可以调用一些String类的方法

*Integer类

Integer num = new Integer(7);//值为7
Integer num = new Integer("123");//值为123，前提是字符串为数值型字符串

（返回Integer型）num.valueOf(String str);//将字符串返回Integer类型
(返回int型)num.parseInt(String str);//将字符串返回int类型

String str = Integer.toString(num,int i);//将num用i进制表示，返回值为字符串

（返回int型）num.compareTo(Integer num1);//num与num1比较，相等返回0，小于返回负值，大于返回正值

*Number类

这是一个抽象类，它是其他八个包装类的父类

*Math类

//常量 Math.PI Math.E

Math.random();//返回0.0到1.0之间的数值，不包含1.0
Math.round(double/float);//四舍五入 ，返回int型

指数


Math.exp(a);//获取e的a次方
Math.log(a);//获取lna
Math.log10(a);//获取ln10a
Math.sqrt(a);//获取a的平方根
Math.cbrt(a);//获取a的立方根
Math.pow(a,b);//获取a的b次方

取整

Math.seil(a);//返回大于或等于a的最小整数
Math.foor(a);//返回小于或等于a的最大整数
Math.rint(a);//返回与参数最接近的整数，若同为接近，则取偶数

取最大值、最小值、绝对值

Math.max(a,b);//取a,b之间的最大值
Math.min(a,b);//取a,b之间的最小值
Math.abs(a);//取绝对值

*Random类

Random ran = new Random();
ran.nextInt();//返回一个随机Int值
ran.nextInt(int n);//返回一个0到n-1 之间的int值

ran.nextGaussian();//返回一个概率密度为高斯分布的double型值

*Collections类

Collections.sort(集合);//对集合中的元素进行排序（升序）
Collections.reverse(集合);//对集合中的元素位置进行反转，没有排序功能
Collections.shuffle(集合);//对集合中的元素进行随机排列

T MAX = Collections.max(集合);//获取集合中最大元素
T MIN = Collections.min(集合);//获取集合中最小元素
int t = Collections.binarySearch(集合，T类型数据);//集合必须为升序序列，若有数据则返回数据第一个索引，若没有则返回-（最近插入点+1）

2、集合

注意：

集合中的类型必须是引用类型

int ==> Integer char ==> Character

Collections.sort(list);// 对集合进行自然排序（仅限于八大封装类）

其他集合要想实现排序功能，必须实现Comparable接口，重写compareTo()方法，T的类型应与继承类一致。

其他集合要想实现排序功能，还可以实现Comparator接口，重写compare()方法，T的类型应与继承类一致。还要在集合的对象实例中new实现类。

*遍历

*迭代器Iterator遍历

三种集合均可用迭代器遍历
Iterator<Type> it = 集合类型.iterator();//创建迭代器

while(it.hasNext()){//判断是否有下一个元素
    System.out.println(it.next());//输出集合中当前元素
}

*map集合专属遍历

Map<K,V> map = new HashMap<>();
Set<Entry<K,V>> entryset = map.entrySet();
for(Entry<Integer, String> e : entryset){
    System.out.println(e);
    System.out.println("键为" + e.getKey() + ",值为" + e.getValue());
}

*List集合

List集合关注的是索引，List集合中的元素是有存放顺序的

List<Type> list = new ArrayList<>();//创建List集合对象
list.add(Type);//向集合中添加元素
list.get(索引值);//获取集合中索引处的值
list.set(索引值，Type);//用于替换list集合中索引处的值
list.remove(索引值);//删除索引处的值

*Set集合

Set集合关注唯一性，它的值不允许重复，TreeSet集合自动升序排序，HashSet集合不关心元素顺序。

Set<Type> set = new TreeSet<>();//使用TresSet创建Set集合对象
set.add(Type);//向Set集合中添加元素

*Map集合

Map集合关注的是唯一的标识符key,HashMap集合输出的元素是无序的（与原始填充顺序也不一致），TreeMap集合能够按照指定顺序输出Map集合中的元素。

*创建并初始化Map集合*

Map<K,V> map = new HashMap<>();//创建Map集合对象
map.put(K,V);//向map集合中添加元素

获取Map集合中的键。返回的是Set集合，可以用Iterator迭代器遍历。

Set<K> set = map.keySet();//构建Map集合中所有key的Set集合
Iterator<K> it = set.iterator();//创建迭代器

while(it.hasNext()){
    System.out.println(it.next());
}

获取Ma集合中的键对应的值,通过map.get(键)获取map集合中的值;

TreeMap<K,V> treemap = new TreeMap<>();//创建TreeMap集合对象
treemap.putAll(map);//将map中的元素添加到集合

Set<K> set = treemap.keySet();//构建Map集合中所有key的Set集合
Iterator<K> it = set.iterator();//创建迭代器

while(it.hasNext()){
    System.out.println(treemap.get(it.next()));
}

直接获取Map集合的值的集合

Collection<V> coll = map.values();//获取map集合中所有values值的集合
Iterator<V> it = coll.iterator();//创建迭代器
while(it.hasNext()){//输出所有的值
    System.out.println(it.next());
}

3、日期

//获取本机所在时区

TimeZone t = TimeZone.getDefault();

//获取本时区的名字

t = getDisplayName();

//根据ID获得时区

t = getTimeZone(String ID);

*Date类日期

将一个日期对象格式化

//日期格式化
SimpleDateFormat sdf = new SimpleDateFormat("yy/MM/dd  hh:mm:ss");
String str = sdf.format(date);

*Calendar类

Calendar对象一般如下定义

Calendar  cal= Calendar.getInstance();

DATE与DAY_OF_MONTH 代表当前天在当前月中是第几天

DAY_OF_WEEK 代表每个月的第一天是星期几

获取当前月最大的天数

4、线程

Thread thread = new Thread(); //创建线程对象

Thread.currentThread()//获取当前线程
thread.start(); //启动线程
thread.getName(); //返回当前线程的名字
thread.getID(); //返回当前线程的ID
thread.setName(); //设置当前线程的名字
thread.getThreadGroup(); //获取当前线程所在的线程组
thread.sleep(2000);//使线程休眠2000毫秒（2秒）
thread.interrupt();//线程中断，不能立即中断，还需要再run()方法中判断是否中断，才会中断
threadB.join();//在threadA线程中加入threadB线程

//使用线程两种方法

//通过继承Thread类
(1)创建一个继承Thread类的子类
    public class ThreadText extends Thread{
        
    }
(2)重写Thread类的run()方法
    public void run(){
    
}

（3）在测试类中创建线程子类的一个对象
   		 ThreadText threadText = new ThreadText();
（4）通过线程类的对象调用start()方法启动线程（启动之后会自动调用覆写的run()方法执行线程）    
   		threadText.start();

//通过实现Runnable接口

（1）创建Runnable对象

Roll roll = new Roll();//Roll类已实现Runnable接口

（2）使用参数为Runnable对象的构造方法创建Thread对象

Thread thread = new Thread(roll);

（3）调用start()方法启动线程

thread.start();

5.IO流

这四类是基类不能直接new，只能new子类

记住读取打印只能是字符串

*File类

File类只能操作文件或目录，不能修改文件内容，new File并不是创建文件，只是创建对象

File file = new File("文件路径");
file.mkdir();//创建一个文件夹
file.mkdirs();//创建新的文件夹，包括不存在的父文件夹（也就是目录），不能创建文件

file.creatNewFile();//创建文件，前提是文件夹已经存在

//获取C盘下的所有文件和文件夹
File file = new File("C://");
File files[] = file.listFiles();

*字节流

一般处理图片，音频，影视

String str = “张三”;
byte[] b = str.getBytes();//将字符串转换为字节存到字节数组

1、InputStream读取字节流

向程序输入的流,一般处理图片，音频，影视

FileInputStream fis = new FileInputStream("文件路径");
int flag = 0;
byte b[] = new byte[1024];//一般是1024
while((flag = fis.read(b))!=-1){//将fis文件中的字节缓存到字节数组b中
    String str = new String(b);//将数组b转化为字符串
    System.out.println(str);//将fis文件中的内容打印到控制台
}
fis.close();//关闭输入流

2、OutputStream输出字节流

向内存输出的流

FileOutputStream fos = new FileOutputStream("文件路径");
int flag = 0;
byte b[] = new byte[1024];//一般是1024
/*
*将fis文件内容复制到fos
*/
while((flag = fis.read(b))!=-1){//将fis文件中的字节缓存到字节数组b中
    fos.write(b);
}
fos.close();//关闭输入流

*字符流

一般处理文件类型

1、Reader读取字符流

向程序读取

FileReader fr = new FileReader("文件路径");
int flag = 0;
char ch[] = new char[1024];//用于存储fr文件内容
while((flag = fr.read(ch))!=-1){//将fr文件内容存储到ch数组
    String str = new String(ch);//将数组转化为字符串
    System.out.println(str);//在控制台打印
}
fr.close();//关闭流

2、Write输出字符流

向内存写入

//复制fr文件内容写到fw中
FileWriter fw = new FileWrite("文件路径");
int flag = 0;
char ch[] = new char[1024];
while((flag = fr.read(ch))!=-1){
    //方法一,字符数组写入
    fw.write(ch);
    //方法二，字符串写入
    String str = new String(ch);
    fw.write(str);
}
fw.close();

*缓冲流

1、字节缓冲流

*BufferedInputStream读取缓冲流

FileInputStream fis = new FileInputStream("文件路径");
BufferedInputStream bis = new BufferedInputStream(fis);
byte b[] = new byte[1024];
while(bis.read(b)!=-1){
String str = new String(b);//字节流必须将字节数组转化为字符串才能打印
System.out.println(str);
}
bis.close();
fis.close();

*BufferedOutputStream输出缓冲流

FileOutputStream fos = new FileOutputStream("文件路径");
BufferedOutputStream bos = new BufferedOutputStream(fos);
byte b[] = new byte[1024];
while(bis.read(b)!=-1){
bos.write(b);//将b的内容写入文件，注意b是字节数组
}
bis.close();
fis.close();

2、字符缓冲流

*BufferedReader读取缓冲流

FileReader fr = new FileReader("文件路径");
BufferedReader br = new BufferedReader(fr);
//方法一，按行读取
String str = "";
while((str = br.readLine())!=null){
    System.out.println(str);
}
//方法二，按字符数组读取
char ch[] = new char[1024];
while(br.read(ch)!=-1){
    String str = new String(ch);//转换成字符串
    System.out.println(str);
}
br.close();
fr.close();

*BufferedWriter输出缓冲流

FileWriter fw = new FileWriter("文件路径");
BufferedWriter bw = new BufferedWriter(fw);
//方法一，按字符串写入
while(br.readLine()!=null){
bw.write(str);    
}
//方法二，按字符数组写入
char ch[] = new char[1024];
while(br.read(ch)!=-1){
    bw.write(ch);
}
bw.close();
fw.close();

* 数据流有2个

1、DataInputStream字节读取数据流

FileInputStream fis = new FileInputStream("文件路径");
DataInputStream dis = new DataInputStream(fis);
//通过readXxx()方法读取文件内容
dis.readBoolean();
dis.readDouble();
dis.readInt();
dis.readChar();
     ...
dis.close();
fis.close();

2、DataOutputStream字节输出数据流

FileOutputStream fos = new FileOutputStream("文件路径");
DataOutputStream dos = new DataOutputStream(fos);
    dos.writeUTF("α");
    dos.writeInt(1234567);
    dos.writeBoolean(true);
    dos.writeShort((short)123);
    dos.writeLong((long)456);
    dos.writeDouble(99.98);

dos.close();
fos.close();

*转换流有2个

即是将字节流转换成字符流

1、InputStreamReader读取转换流

FileInputStream fis = new FileInputStream("文件路径");
//此时的isr相当于Reader
InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
//也可以转换成缓冲流,也可以直接用下面图片的方法读取
BufferedReader br = new BufferedReader(isr);
//方法一，按行读取
String str = "";
while(br.readLine()!=null){
    System.out.println(str);
}
//方法二，按字符数组读取
char ch[] = new char[1024];
while(br.read(ch)!=-1){
    String str = new String(ch);//转换成字符串
    System.out.println(str);
}
br.close();
isr.close();
fis.close();

2、OutputStreamWriter输出转换流

FileOutputStream fos = new FileOutputStream("文件路径");
//此时的osw相当于Writer
OutputStreamWriter osw = new OutputStreamWriter(fos);
//也可以转换成缓冲流,也可以直接用下面图片的方法读取
BufferedWriter bw = new BufferedWriter(fos);
//方法一，按字符串写入
while(br.readLine()!=null){
bw.write(str);    
}
//方法二，按字符数组写入
char ch[] = new char[1024];
while(br.read(ch)!=-1){
    bw.write(ch);
}
bw.close();
osw.close();
fos.close();

*打印流有2个

1、PrintStream字节打印流

PrintStream ps = new PrintStream("文件路径");
ps.print("...");//打印进文件中的内容不能换行
ps.println("...");//可以换行
ps.close();

2、PrintWriter字符打印流

PrintWriter pw = new PrintWriter("路径");
pw.print();//不换行
pw.println();//换行
pw.close();

*序列化与反序列化

序列化是指将java对象转化成二进制文件进行储存,实例对象必须实现Serializable接口,序列化与反序列化必须组合使用

//序列化
FileOutputStream fos = new FileOutputStream("路径");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(实例对象);
oos.close();
fos.close();

//反序列化
FileInputStream fis = new  FileInputStream("与上面路径一致");
ObjectInputStream ois = new ObjectInputStream(fis);
ois.readObject();//向下转型为实例对象后才能打印
ois.close();
fis.close();

*Properties文件配置

//向配置文件中写入配置信息
FileOutputStream fos = new FileOutputStream("D:/io3/user.properties");
Properties config = new Properties();
config.setProperty("userName", "admin");
config.setProperty("userPwd", "admin");
config.store(fos, "store infos");
fos.close();

//从配置文件中读取配置信息
FileInputStream fis = new FileInputStream("D:/io3/user.properties");
config.load(fis);
String key = "userName";
String value = (String) config.getProPerty(key);
System.out.println("key:"+key+"\nvalue:"+value);
fis.close();

//获取用户最后一次登录系统的时间
//获取系统本地的当前时间，并将其转换为字符串
String now = LocalDateTime.now().toString();

6、数据库

*连接数据库

//连接数据库
public class TestJDBC {
	static Connection con; // 声明Connection对象，代表java端与数据库之间的连接
	static PrepareStatement ps; // 声明Statement对象，用来执行SQL语句
	static ResultSet res; // 声明ResultSet对象，用来暂时存放结果

public static void main(String[] args)  {
		TestJDBC c = new TestJDBC(); // 创建本类对象
		con = c.getConnection(); // 与数据库建立连接(调用连接数据库的方法)
		try {
            //这里填写各种操作代码如添加
    // 向数据表user中动态添加account,mima,menu,name,sex,phone这六列的值
ps = con.prepareStatement("insert into user(account,mima,menu,name,sex,phone) value(?,?,?,?,?,?)");
// 添加数据
ps.setString(1, "LB");
ps.setString(2, "0000");
ps.setString(3, "JAVA");
ps.setString(4, "栾勇");
ps.setString(5, "男");
ps.setString(6, "13721131205");
ps.executeUpdate();// 执行添加语句
System.out.println("添加成功");
            
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	public Connection getConnection() { // 连接数据库方法
		try {
			// 该语句用于加载数据库
			Class.forName("com.mysql.cj.jdbc.Driver");
			// 该语句用于连接数据库
			con = DriverManager.getConnection("jdbc:mysql:" + "//127.0.0.1:3306/lysjk" + "?serverTimezone=GMT ", "root","1234");// lysjk为数据库名
			System.out.println("链接成功");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return con; // 返回Connection对象
	}
}

// 实例化Statement对象
ps = con.createStatement();
// 执行SQL语句，返回结果集
res = ps.executeQuery("select * from user");

//等同于

ps = con.prepareStatement("select * from user");
res = ps.executeQuery();

//语句可替换
ps = con.prepareStatement("select * from user where account = ?"); // 实例化Statement对象
ps.setString(1, "B");
res = ps.executeQuery();// 执行SQL语句，返回结果集

//等同于

ps = con.prepareStatement("select * from user where account = 'B'"); // 实例化Statement对象
res = ps.executeQuery();// 执行SQL语句，返回结果集

*添加数据

//添加数据
// 向数据表user中动态添加account,mima,menu,name,sex,phone这六列的值
ps = con.prepareStatement("insert into user(account,mima,menu,name,sex,phone) value(?,?,?,?,?,?)");
// 添加数据
ps.setString(1, "LB");
ps.setString(2, "0000");
ps.setString(3, "JAVA");
ps.setString(4, "栾勇");
ps.setString(5, "男");
ps.setString(6, "13721131205");
ps.executeUpdate();// 执行添加语句
System.out.println("添加成功");

*修改数据

//修改数据
// 根据指定account动态更改数据表user中name列的列值
public void xiuGai() {
		try {
	// 根据指定account动态更改数据表user中name列的列值
			ps = con.prepareStatement("update users set num = ? where name = ?");
	// 下面两行的意思是为account为LA的那一行数据中的name列赋值为栾康，即可实现修改数据
			ps.setString(1, "栾康");// 为name列赋值
             ps.setString(2, "LA");// 为account赋值
		int result = ps.executeUpdate();// 执行修改语句
			if (result > 0) {
				System.out.println("修改成功");
			} else {
				System.out.println("修改失败");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

*删除数据

//删除数据
//方法一
Statement tate = con.createStatement();
tate.executeUpdate("delete from user where account = 'LA'");// 删除account为LA的那一行数据
System.out.println("删除成功");

//方法二
ps = con.prepareStatement("delete from user where account = 'ZY'");
ps.executeUpdate();
System.out.println("删除成功");

*查询数据

//查询数据
//查询users数据表中的数据
public void show() {
	try {
		ps = con.prepareStatement("select * from users"); // 实例化Statement对象
			res = ps.executeQuery();// 执行SQL语句，返回结果集
			while (res.next()) { // 如果当前语句不是最后一条则进入循环
				String account = res.getString(1); // 获取结果集中第一列的值
				String mima = res.getString("num");// 获取列名是"num"的字段值
                
				System.out.print("账号：" + account); // 将列值输出
				System.out.println(" mima:" + mima);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}