Java基础

最新推荐文章于 2023-10-23 23:59:24 发布

迪杰斯特夫

最新推荐文章于 2023-10-23 23:59:24 发布

阅读量1.5k

点赞数 1

分类专栏：岗前培训 java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_51330179/article/details/121049214

版权

岗前培训同时被 2 个专栏收录

4 篇文章 3 订阅

订阅专栏

java

3 篇文章 0 订阅

订阅专栏

Java基础入门

Java概述
java基础
面向对象基础
eclipse使用
- Eclipse 常用快捷键
异常
工具类
正则表达式
集合类
泛型
文件

Java概述

java虚拟机概述

公司指定的jdk版本

jdk1.8.0_201.zip

安装java，配置环境变量

//行注释

/*块注释*/
public class Demo04{
	public static void main(String[] args){
		System.out.println("helloWord你好");
	}
}

基本命令

以指定的编码格式编译文件

javac -encoding 编码格式（utf-8）文件名（Hello.java）

执行

java文件名（不带后缀）

java基础

目标：

掌握Java基本数据类型和引用类型
掌握Java常用运算符
掌握Java的流程控制语句

数据类型和变量

基本数据类型

取值范围&默认值

类型转换

自动类型转换&强制类型转换

精度大的转小的需要强制类型转换：

public class Demo{
	public static void main(String[] args){
		int a = 1;
		//short b = a;//编译不通过
		short b =  (short)a;//正确写法
	}
}

注意：char类型和short是平级的，两者转换需要强制类型转换

引用数据类型

引用类型用来指向一-个对象，指向该对象的变量称为引用变量。
这些变量在声明时被指定为一个特定的类型，变量一旦声明后，类型就不能被
改变了。
对象、数组都是引用数据类型。
所有引用类型的默认值都是null。
一个引用变量可以用来引用任何与之兼容的类型。
例子: Site site = new Site(“Runoob”)。

变量

Java中使用每个变量前都必须先声明该变量,声明的语法格式:
[变量类型] [变量名];
变量可以被初始化和赋值。
变量名区分大小写，多个同类型的变量声明以’, '隔开。
变量类型
●类变量:独立于方法之外的变量，用static 修饰。
●实例变量:独立于方法之外的变量,没有static 修饰。
●局部变量:类的方法中的变量。

变量声名：long和float赋值需要在数字后面加上后缀L和f

标识符命名规范

关键字：

运算符

运算符是一种特殊的符号，用来表示数据的运算、赋值和比较等

分为以下几种
●算术运算符
●赋值运算符
●比较运算符
●逻辑运算符
●三目运算符
位运算符(了解)
表达式就是由一系列运算符和操作数组成的。

短路与和或的效率比与和或高

三目运算符

优先级：

流程控制

条件语句

if (表达式){
语句块1;
}else if{
语句块2;
}else {
语句块3;
}

注意：不要省略if后面的大括号

switch (表达式){
case 1:
操作1的语句;
break;
case 2:
操作2的语句;
break;
case n :
操作n的语句;
break;
default:
默认语句;

}

循环语句

while循环：

While ( 条件=true){
执行语句块;}

do-while语句的语法为:
do
执行语句块;
}while(条件=true)

for语句的语法为:
for(初始化;表达式;增量){
操作语句;
}
增强for循环
String[] strs= [“a”,“b”];
for(String s:strs){

}

**三种跳转语句为: **

break
continue
return
break语句:结束整个循环，嵌套循环时一-般用于结束内层循环。
continue语句:结束本次循环的其它语句，继续下一次循环。
return:用于结束(终止)方法的执行

数组

定义：

由类型相同的元素组成的有顺序的数据集合，数组的长度不可变

声名：

●通用的一维数组的声明格式是:
数据类型[]数组名; 或数据类型数组名[];
举例:
String [ ] strs ;
int array[] ;

初始化：

所谓初始化，就是为数组的数组元素分配内存空间，并为每个数组元素赋初
始值。
数组初始化:

//静态初始化

strs = new String[] {“赵”,“钱”,“孙”}; 或strs = {“赵”,“钱”,“孙”};

//动态初始化，只定义数组长度

array = new int[6];

基本数据类型&引用数据类型

区别在于初始化的时候的默认值

数组使用：

利用下标直接访问
利用length属性获取数组长度
利用for循环，增强for循环遍历访问
使用Arrays工具类进行打印，排序等等操作

二维数组：

数组元素的引用还是数组

定义方式
int0] arrays;
二维数组是指数组的元素实质也是一个数组，即数组元素的引用指向一维数组。
初始化
arrays = new int[length]);
二维数组遍历
使用嵌套循环遍历
TwoDimensionDemo.java

常见异常

索引越界异常
ArrayIndexOutOfBoundsException
空指针异常
NullPointException

方法

格式:访问修饰符方法类型返回值类型方法名(参数类型参数1，参数类型参数…)
函数体(变量声明、流程控制等代码)
}
方法修饰符: public private protected default
方法类型: static修饰的为类方法(静态方法)和无static修饰的成员方法
返回值类型:基本数据类型或复合数据类型(需要在方法最后return) ，也可以没有返回值(void)
方法名:符合方法命名规范，驼峰命名方式，首字母小写
参数列表:参数类型即数据类型，参数即变量

可变个数形参：

在定义方法时，如果在最后-个形参的类型后添加英文三点(…)，则表明该形参可以接受多
个参数值，多个参数值当成数组传入。

利用args数组后台进行传参数：

方法的重载：

如果一个类中包含了两个或两个以上方法的方法名相同，但形参列表不同，则称为方法重载。
重载要求:两同一不同
1、同一个类中。
2、方法名相同。
3、形参列表不同，包含参数类型和参数个数，与方法有无返回值无关。
注意:
1、仅有返回类型不同是不足以区分两个重载的方法。
2、涉及基本数据类型的重载，要注意基本数据类型会从-一个"较小”的
类型提升到一个“较大”的类型，重载可能出现混淆。
3、可变参数的方法重载，传入单个参数时，需要使用数组方式传值，一
般不推荐重载可变参数的方法

面向对象基础

类和对象的关系

类的定义

[访问修饰符] class类名

{
成员变量…
[访问修饰符]类型成员变量名[=默认值];
构造方法定义…
方法定义…

}

命名规范：有意义单词，驼峰法

成员变量：表示该类的属性

实例变量——非static修饰，通过实例调用来访问，通过对象点变量的方法来调用
类变量——static修饰的变量，可通过类名变量名访问
构造方法:用于初始化类，Java为每一个类提供一个无参的构造方法
方法:用来定义类或实例的行为或功能实现
命名规范:参考变量和方法部分命名规范

构造方法详解：

系统默认提供无参构造方法
一旦显式的声明了构造方法，系统就不再提供默认无参构造方法
修饰符:默认，public、 private、 protected
规则:
与类名相同
参数列表与方法定义相同
构造方法不能定义返回值类型，也不能使用void,当使用new创建时构造方法默认
返回当前类的实例

static关键字：

在一个类内
static修饰的方法不能调用非static修饰的方法
static修饰的方法不能调用非static修饰的成员变量(非静态变量)
即静态成员不能调用非静态成员
注意点:
static修饰的方法可以直接使用类来调用，故this在此方法中无法指向
合适的对象。所以，static修饰的方法中不能使用this弓|用。

封装

将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，
而是通过该类所提供的方法来实现对内部信息的操作和访问。
示例:设置人员年龄引发的逻辑错误

将对象的成员变量和实现细节隐藏起来，不允许外部直接访问
将方法暴露出来，通过方法来控制对变量进行安全的访问和操作
示例:封装人员类的属性，定义get/set方法

权限修饰符：

包相关

package
用于解决类重名问题
引入方式:在第一个非注释行引入package packagename;
命名方式:有明确含义的全小写字母，例如com.epoint
示例:编译生成带包名的class文件，添加-d . 选项
import
用于简化程序，导入指定包下的类，*表示导入该包下所有类
Java默认为所有源文件导入java.lang包下的所有类
注意util和sql日期类问题

没有导包要写全类名，同名情况也要写全类名

import static
静态导入，导入类变量或类方法(静态变量，静态方法)

注意：带包名的编译需要加-d 后面跟生成目录，在当前目录就用 .

运行的时候要加上包名

常用的工具包：

java.lang:包含Java语言的核心类系统自动导入
java.util:包含大量工具类/接口和集合类/接口Arrays List Set
java.net:网络编程相关
java.io:文件io流
java.text: java格式化相关
java.sql: jdbc数据库编程相关类/接

继承

实现代码复用，Java具有单继承的特点，即一个类只能有一个直接父类。
语法:

修饰符 class SubClass extends SuperClass{

//类定义内容

}

如果没有明确的使用extends继承父类，则该类的默认父类为java.lang.Object
使用继承后，子类SubClass将获得父类SuperClass除private修饰外的所有成员
变量和方法。

重写父类的方法

规则:
■方法名相同、参数列表相同
子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出
的异常类应比父类方法声明抛出的异常类更小或相等
■子类方法的访问权限应比父类方法的访问权限更大或相等
■private修饰的方法，子类不能重写
示例:人类工作，教师教书，程序员搬砖
常见重写Object类中的方法
toString();
equals();

可以用@Override的注解来检查是否成功重写

super关键字：可以用来调用父类的方法(super.方法();)调用父类的构造器(super()😉,子类总会调用一次父类的构造方法

最好提供无参构造

多态

编译期间的类型和运行时的类型不一致

实例变量不具有多态性，方法才有多态性

概念:编译期类型和运行期类型不一致，例如子类赋值给父类变量
对象的实例变量不具备多态性，方法具有多态性
向上转型:把-个子类对象直接赋值给一个父类引用变量
强制类型转换: (type) 变量;
要求两个类之间必须有继承关系，如果把一个父类实例转换成子类类型,
则这个对象实际上必须是子类实例，否则运行时弓|发ClassCastException异常
示例
Object和String可以强制转换
Object值为int，int不能转换为String
instanceof运算符可以用来判断变量类型
●通常先用instanceof判断对象是否可以强转后，再使用type进行强制类型转换
示例:优化int转String部分代码，添加类型判断

组合

组合&继承

组合适用于一个的情况

final关键字

可修饰类、变量、方法，修饰后不可改变
修饰成员变量(类变量、实例变量)
■final修饰的成员变量必须由程序员显式的指定初始值
■final修饰基本数据类型和引用类型的区别，引用类型引用的地址不可更改，但
引用的对象内容可变
修饰方法:不可被重写
Object getClass()
修饰类:不能被继承，不可以有子类
String类Math类包装类

接口

将抽象进行的更彻底
接口定义了一种规范，定义了某一批类所需要遵守的规范，接口不关心这些类的
内部属性和具体方法实现，只规定这批类里必须提供某些方法。
接口体现了规范和实现分离的设计哲学
Java 8中接口的定义
[修饰符] interface 接口名extends 父接口1，父接口2…{
常量定义;
默认方法定义: default 返回值方法名(参数列表) {方法体}
抽象方法定义
}
修饰符:只能是public或默认
命名规范:同类命名规范

接口中的常量

静态常量:系统自动为接口里定义的成员变量添加public static fina|修饰符
定义方法:普通方法默认添加abstract修饰符;类方法和默认方法必须有方法体
实现
接口的继承:多继承，逗号分隔

接口和抽象类的对比

相同点
●都不能被实例化
●都可以包含抽象方法，实现接口或继承抽象类的普通子类必须实现这些抽象
方法
不同点
●接口不能为普通方法提供方法实现;抽象类可以包含普通方法
●接口里不能定义静态方法;抽象类可以定义静态方法
●接口里只能定义静态常量;抽象类可以定义静态常量，也可以定义普通成员
变量
●接口里不包含构造方法;抽象类可以包含构造方法，主要用于被其子类调用
●一个类最多只能有一个直接父类，包括抽象类;一个类可以实现多个接口
●接口里不包含初始化代码块;抽象类里可以包含初始化代码块

面向接口编程：简单工程模式

示例:简单工厂模式
假设程序中有个Computer类需要组合一个输出设备，需考虑输出设备存
在升级更新的情况。

System. arraycopy(源数组，源数组起始位置，目标数组，目标数组起始位置，源数组起始位置的长度)：将一个数组拷贝到另一个数组

package com.day5;

public class demo {
    public static void main(String[] args) {
        OutputFactory outputFactory = new OutputFactory();
        Output output = outputFactory.getOutput(1);
        Computer computer = new Computer(output);
        computer.KeyIn("sdfhbuhbudb");
        computer.out();
    }

}

class Computer{
    private Output out;

    public Computer(Output out){
        this.out=out;
    }
    //输入数据
    public void KeyIn(String msg){
        out.getData(msg);
    }

    //输出信息
    public void out(){
        out.out();
    }
}

interface Output{
    int Max_Line=50;
    public void getData(String msg);
    public void out();
}


class Printer implements  Output{
    private String[] printData=new String[Max_Line*2];
    private int dataNum = 0;
    @Override
    public void getData(String msg) {
        if (dataNum>=Max_Line*2){
            System.out.println("信息已满");
        }else {
            printData[dataNum++]=msg;
        }
    }

    @Override
    public void out() {
        while (dataNum>0){
            System.out.println(printData[0]);
            System.arraycopy(printData,1,printData,0,--dataNum);
        }

    }
}

/**
 * 新设备
 * 后面的数据库连接也是用的工厂模式
 */
class BetterPrinter implements Output{

    @Override
    public void getData(String msg) {

    }

    @Override
    public void out() {

    }
}


class OutputFactory{
    public Output getOutput(int flag){
        if (flag==1){
            return new Printer();
        }else {
            //动态更新设备，不需要进行代码修改
            return new BetterPrinter();
        }
    }
}

示例:命令模式动态配置行为
假设有个方法需要遍历某个数组的数组元素，但无法确定在遍历数组元素
时如何处理这些元素，需要在调用该方法时指定具体的处理行为。

具体的实例方法在调用的时候才确定

public class Demo02 {
    public static void main(String[] args) {
        ProcessArrayCommand processArrayCommand = new ProcessArrayCommand();
        int[] src= {2,6,4};
        processArrayCommand.processArray(src,new PrintArray());
        processArrayCommand.processArray(src,new SumArray());
        
    }
}

interface Command{
    public void processArray(int[] src);
}

//打印数组信息
class PrintArray implements Command{

    @Override
    public void processArray(int[] src) {
        for(int temp:src){
            System.out.println(temp);
        }
    }
}

//求和
class SumArray implements Command{

    @Override
    public void processArray(int[] src) {
        int sum=0;
        for(int temp:src){
            sum+=temp;
        }
        System.out.println(sum);
    }
}

class ProcessArrayCommand{
    public void processArray(int[] src,Command cmd){
        cmd.processArray(src);
    }
}

对象初始化

静态代码块：

语法：

class T{

static{}//静态代码块

}

在使用一个类之前，虚拟机需要从外部加载这个类文件，静态代码块
在类加载完毕后会自动执行一-次
多个代码块按定义的先后顺序执行

如果有继承关系，先加载父类再加载子类，只会执行一次

初始化代码块：

语法:
class T{
//初始化代码块，在执行构造方法内的代码前执行
}
不能在外部调用，只能在创建Java对象时隐式执行,并在执行构造方法之前执行。
多个代码块按定义的先后顺序执行

对象初始化的过程

1.从顶级父类开始加载，每个类加载后执行其static代码块
2.从顶级父类的构造方法开始执行，如果某个类有非静态初始化代码块,
先执行这个代码块再执行构造方法内的语句。
示例:代码块、静态代码块、继承中的初始化顺序

注意：不能在static代码块中引用非静态代码块

单例模式

一般构造方法权限修饰符都为public, 某些情况下，不允许其他类自由创建
该类的对象。例如任务管理器，创建多个对象没有意义的情况下，使用单例模
式
一个类始终只能创建一个实例，则这个类称为单例类
步骤:
①私有化构造方法
②提供一个public方法，并用static修饰，因为调用时还没有对象存在，只能类
调用
③添加一个静态变量用于缓存已经创建的对象

public class Demo {
    private static Demo instance;
    private Demo(){

    }

    public static Demo getInstance(){
        if (null == instance){
            instance=new Demo();
        }
        return instance;
    }

    public static void main(String[] args) {
        System.out.println(Demo.getInstance());
    }
}

补：System.identityHashCode(instance)可以计算对象的哈希值

垃圾回收

通常jre会提供一个后台线程来进行检测和控制，一般都是在CPU空闲或内存不足时
自动进行垃圾回收，程序无法精确控制垃圾回收的时间和顺序。
垃圾回收特征:
①只负责回收堆内存中的对象(例如对象、数组等引用类型实体)，不会回收任何
物理资源
②程序无法精确控制垃圾回收的运行，当对象永久性地失去引用后，系统就会在合
适的时候回收它所占的内存。
③在回收任何对象之前，总会先调用它的finalize()方法,该方法可能使该对象重新
复活(让一个引用变量重新引用该对象)，从而导致垃圾回收机制取消回收。
代码编写规则:对于不再需要的对象，不要引用它们

finalize（）

强制回收

可通过调用Runtime对象的gc()或System.gc()等方法建议系统进行垃圾回收,
但这种调用仅仅是建议，依然不能精确控制垃圾回收机制的执行
System.gc();
Runtime.getRuntime.gc();
示例:调用finalize() 和System.gc();
运行命令java -verbose:gc TestGC可以查看垃圾回收的情况

系统在调用gc()之前会先调用finalize()方法，重写finalize方法可以再回收对象之前需要做的事情

eclipse使用

Eclipse 常用快捷键

快捷键	描述
编辑
Ctrl+1	快速修复（最经典的快捷键,就不用多说了，可以解决很多问题，比如import类、try catch包围等）
Ctrl+Shift+F	格式化当前代码
Ctrl+Shift+M	添加类的import导入
Ctrl+Shift+O	组织类的import导入（既有Ctrl+Shift+M的作用，又可以帮你去除没用的导入，很有用）
Ctrl+Y	重做（与撤销Ctrl+Z相反）
Alt+/	内容辅助（帮你省了多少次键盘敲打，太常用了）
Ctrl+D	删除当前行或者多行
Alt+↓	当前行和下面一行交互位置（特别实用,可以省去先剪切,再粘贴了）
Alt+↑	当前行和上面一行交互位置（同上）
Ctrl+Alt+↓	复制当前行到下一行（复制增加）
Ctrl+Alt+↑	复制当前行到上一行（复制增加）
Shift+Enter	在当前行的下一行插入空行（这时鼠标可以在当前行的任一位置,不一定是最后）
Ctrl+/	注释当前行,再按则取消注释
选择
Alt+Shift+↑	选择封装元素
Alt+Shift+←	选择上一个元素
Alt+Shift+→	选择下一个元素
Shift+←	从光标处开始往左选择字符
Shift+→	从光标处开始往右选择字符
Ctrl+Shift+←	选中光标左边的单词
Ctrl+Shift+→	选中光标右边的单词
移动
Ctrl+←	光标移到左边单词的开头，相当于vim的b
Ctrl+→	光标移到右边单词的末尾，相当于vim的e
搜索
Ctrl+K	参照选中的Word快速定位到下一个（如果没有选中word，则搜索上一次使用搜索的word）
Ctrl+Shift+K	参照选中的Word快速定位到上一个
Ctrl+J	正向增量查找（按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在状态栏中显示没有找到了,查一个单词时,特别实用,要退出这个模式，按escape建）
Ctrl+Shift+J	反向增量查找（和上条相同,只不过是从后往前查）
Ctrl+Shift+U	列出所有包含字符串的行
Ctrl+H	打开搜索对话框
Ctrl+G	工作区中的声明
Ctrl+Shift+G	工作区中的引用
导航
Ctrl+Shift+T	搜索类（包括工程和关联的第三jar包）
Ctrl+Shift+R	搜索工程中的文件
Ctrl+E	快速显示当前Editer的下拉列表（如果当前页面没有显示的用黑体表示）
F4	打开类型层次结构
F3	跳转到声明处
Alt+←	前一个编辑的页面
Alt+→	下一个编辑的页面（当然是针对上面那条来说了）
Ctrl+PageUp/PageDown	在编辑器中，切换已经打开的文件
调试
F5	单步跳入
F6	单步跳过
F7	单步返回
F8	继续
Ctrl+Shift+D	显示变量的值
Ctrl+Shift+B	在当前行设置或者去掉断点
Ctrl+R	运行至行(超好用，可以节省好多的断点)
重构（一般重构的快捷键都是Alt+Shift开头的了）
Alt+Shift+R	重命名方法名、属性或者变量名（是我自己最爱用的一个了,尤其是变量和类的Rename,比手工方法能节省很多劳动力）
Alt+Shift+M	把一段函数内的代码抽取成方法（这是重构里面最常用的方法之一了,尤其是对一大堆泥团代码有用）
Alt+Shift+C	修改函数结构（比较实用,有N个函数调用了这个方法,修改一次搞定）
Alt+Shift+L	抽取本地变量（可以直接把一些魔法数字和字符串抽取成一个变量,尤其是多处调用的时候）
Alt+Shift+F	把Class中的local变量变为field变量（比较实用的功能）
Alt+Shift+I	合并变量（可能这样说有点不妥Inline）
Alt+Shift+V	移动函数和变量（不怎么常用）
Alt+Shift+Z	重构的后悔药（Undo）
其他
Alt+Enter	显示当前选择资源的属性，windows下的查看文件的属性就是这个快捷键，通常用来查看文件在windows中的实际路径
Ctrl+↑	文本编辑器上滚行
Ctrl+↓	文本编辑器下滚行
Ctrl+M	最大化当前的Edit或View （再按则反之）
Ctrl+O	快速显示 OutLine（不开Outline窗口的同学，这个快捷键是必不可少的）
Ctrl+T	快速显示当前类的继承结构
Ctrl+W	关闭当前Editer（windows下关闭打开的对话框也是这个，还有qq、旺旺、浏览器等都是）
Ctrl+L	文本编辑器转至行
F2	显示工具提示描述

异常

异常指的是程序出现未经期望的错误
Java中的异常机制指的是对这些异常进行处理的方式，异常机制使代码的阅读、编写
和调试工作更加井井有条。

异常继承体系

Error异常:常为Jvm异常，不期望程序捕获，-一般不做处理
Exception异常:
●运行时异常(RuntimeException) :程序可编译,运行时会产生该异常，一-般需处
理
●非运行时异常(即checked异常) :程序编译不通过，提醒需要处理该异常，需显，
式处理

处理方式

try{
//可能产生异常的代码
}catch(exceptionclass e1){
//异常处理
}
catch(exceptionclass2 e2){
//异常处理
}

捕获的时候范围从小到大

filnally

try{
//可能产生异常的代码
}catch(exceptionclass e1){
//异常处理
}
…
finally{
//释放资源“}

throw

如果需要在程序中自行抛出异常，则应使用throw语句， throw抛出的是一个异常实例,
且每次只能抛出- -个异常实例。
语法:
throw ExceptionInstance;//RuntimeException及其派生类
示例:
throw抛出RuntimeException及其派生类
注意:
如果一个方法里利用throw抛出一个非RuntimeException异常, 则必须在函数定义声明里加上throws异常类型

多个throws用逗号分割

此时调用该方法的其他方法必须显式的处理该异常

自定义异常

public class String ToIntException extends Exception{
public String TolntException(){
}
public String ToIntException(String msg){
super(msg);

}

可以精确描述异常

异常跟踪栈

处理规则

异常主要用于处理不确定的异常内容，对于明确的业务异常判断使用-般程序控制语
句，效率比使用异常高
实际编码过程中，捕获异常后不要什么都不做，或仅仅打印异常信息，需要跟踪异常
链

工具类

Scanner

用于获取键盘输入
常用方法:
boolean hasNextXxx():是否还有下一个输入项，其中Xxx可以是Int、Long等代
表基本数据的字符串。
boolean hasNext():获取字符串输入
xXx nextXxx():获取下一-个输入项
String next():获取下一个字符
boolean hasNextL ine();
String nextLine();
Scanner sc = new Scanner(System.in);//System.in代表标准输入，键盘输入
Scanner sc = new Scanner(new File(“a.text’ );//读取文件输入

判断+hasNextXXX

获取+NextXXX

System

runtime

代表Java程序的运行时环境，每个Java程序都有一个与之对应的Runtime实例，
通过getRuntime()获取与之关联的对象。
Runtime rt = Runtime .getRuntime();
rt.availableProcessors();
rt.freeMemory();
rt.totalMemory();
rt.maxMemory();

用到runtime的情况

//windows下的exe可以直接执行
rt.exec(“notepad.exe”);
//执行其它目录下程序
rt.exec(“C:\Program Files (x86)\CCworkllCCwork.exe”);

Object

equals(Object obj);
String toString();
finalize();
Class<?> getClass();
int hashCode();
Java7中的Objects类

Objects

提供对于空指针和null值的判断

String

+运算连接，至少包含一个字符串

在字符串连接之前+还是正常的计算功能

String的equals被重写了，判断内容是否一样

indexOf（String str）查询str出现的位置

matches（正则）判断是否匹配正则表达式

格式化输出

String.formate(String formate,Object … args)

返回一个格式化之后的字符串

用法：

        String formate="年龄:%d,体重：%f,百分比：%.2f%%";
        String format = String.format(formate, 18,90.6,50.0);
        System.out.println(format);

格式化输出printf

StringBuffer可变长度的字符串

字符串可变，线程安全
new StringBuffer();
new StringBuffer(“字符串”);
常用方法:
append( “zfc” );//添加字符串
delete(int start, int end)//移除此序列的子字符串中的字符。左闭右开
replace(int start, int end, String str)
//使用给定String中的字符替换此序列的子字符串中的字符。
int length()
subString(int start);

StringBuilder（同上）

线程不安全，效率高

区别

StringBuilder和Stringbuffer的对象能够多次修改,不产生新的字符串对象
String修改会产生新的对象
StringBuilder线程不安全，但有速度优势，常用
StringBuffer线程安全

Math

常量

math.PI

math.E

方法

1	xxxValue() 将 Number 对象转换为xxx数据类型的值并返回。
2	compareTo() 将number对象与参数比较。
3	equals() 判断number对象是否与参数相等。
4	valueOf() 返回一个 Number 对象指定的内置数据类型
5	toString() 以字符串形式返回值。
6	parseInt() 将字符串解析为int类型。
7	abs() 返回参数的绝对值。
8	ceil() 返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型。
9	floor() 返回小于等于（<=）给定参数的最大整数。
10	rint() 返回与参数最接近的整数。返回类型为double。
11	round() 它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。
12	min() 返回两个参数中的最小值。
13	max() 返回两个参数中的最大值。
14	exp() 返回自然数底数e的参数次方。
15	log() 返回参数的自然数底数的对数值。
16	pow() 返回第一个参数的第二个参数次方。
17	sqrt() 求参数的算术平方根。
18	sin() 求指定double类型参数的正弦值。
19	cos() 求指定double类型参数的余弦值。
20	tan() 求指定double类型参数的正切值。
21	asin() 求指定double类型参数的反正弦值。
22	acos() 求指定double类型参数的反余弦值。
23	atan() 求指定double类型参数的反正切值。
24	atan2() 将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
25	toDegrees() 将参数转化为角度。
26	toRadians() 将角度转换为弧度。
27	random() 返回一个随机数。

随机数-Random

三种方法

Random

ThreadLocalRandom线程安全

Math.random()

BigDecimal

float、double在进行算术运行时容易引起精度丢失
构造方法
推荐使用new BigDecimal(String)
BigDecimal.valueOf(double value);
常用方法
add
subtract
multiply
divide
pow
DecimalFormat格式化数字(四舍五入、百分比、添加货币标识)
NumberFormat格式化

Date–不推荐使用，方法少

构造方法
Date()底层调用System.currentTimeMillis()
Date(long date)
方法
boolean after(Date date)
boolean before(Date date)
long getTime()

日历类-Calendar

抽象类不能实例化
使用getlnstance()获取Calendar对象
常用方法.
getTime()
setTime();
void set(int year,int month,int date)
void get(int field)
void add(int field,int amount)
Calendar的容错性
cal. set(MONTH, 13);//年份会自动加1
cal. setL enient(alse);//关闭容错

LocalTime&LocalDate&LocalDateTime

SimpleDateFormate

SimpleDateFormat
对日期进行格式化处理，主要功能:
将日期按特定的格式转换为字符串
将字符串以某种方式转换为日期
常用方法:
public final String format(Date date)
public Date parse(String source) throws ParseException
void printTime(){
Date now = new Date();
SimpleDateFormat fmt = new SimpleDateFormat(“yyyy-MM-dd
HH:mm:ss”);
System.out.println(fmt.format(now));
String timeInfo = “1986-2-12 12:33:20”;
Date time = fmt.parse(timelnfo);
}

正则表达式

字符串匹配模板，可以对字符串进行查找、提取、分割、替换等操作(匹配、选
择、编辑、验证)
Java中的转义字符\\

Pattern: Pattern对象是正则表达式编译后在内存中的表示形式
Matcher:多个Mather对象可共享同- -个Pattern对象

使用方法：

        Pattern compile = Pattern.compile("a*b");
        Matcher matcher = compile.matcher("aaab");
        boolean s = matcher.matches();
        System.out.println(s);
        
        System.out.println(Pattern.matches("a*b", "aaaaaaaab"));
        
        System.out.println("aaab".matches("\\w*"));

集合类

常见方法

函数式接口

 Collection collection = new HashSet();
        collection.add("JavaEE");
        collection.add(18);
        collection.add(true);
        
        //使用iterature迭代
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()) {
            Object object = (Object) iterator.next();
            System.out.println(object);
        }
        
        //for-each循环
        for(Object o:collection) {
            System.out.println(o);
        }
        
        //函数式接口实现
        collection.forEach(System.out::println);
        //函数式接口实现2
        collection.forEach(obj->System.out.print(obj));

Set接口

无序，不能重复

常见实现类HashSet，TreeSet

判断是否重复的标准

不重复的数据集合，数据重复的判断标准(equals方法比较相同且hashCode值相同)

TreeSet

定制排序

        TreeSet<Student> treeSet = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge()>o2.getAge()?1:-1;
            }
        });
        treeSet.add(new Student("tom",18,"s1000"));
        treeSet.add(new Student("jack",15,"s1001"));
        treeSet.add(new Student("lili",17,"s1002"));
        treeSet.forEach(System.out::println);

List

元素有序可重复

常用方法

Linkedlist

List和HashSet的转换（去重）

在set构造器中加入list

或者set调用addAll方法

Map

key不能重复，value可以相同

Map常用方法

LinkedHashMap、TreeMap

可以保持插入的顺序

treemap可以自定义排序

选用规则

■需要根据键值获取元素值时选用Map接口下的集合
需要排序时选择TreeMap .
●不需要排序时选择HashMap
■当只需要存放元素值时，选择实现Collection接口的集合
●需要保证元素唯一时选择实现Set接口的实现类，比如TreeSet或HashSet
●不需要元素唯一则选择实现L ist接口的实现类，比如ArrayList或L inkedList,
然后再根据实现这些接口的集合的特点来选用。

集合工具类

集合操作类Collections
常用方法:查看api
将集合转换为数组 toArray(接口提供的方法)
转换集合为线程安全
Map m = Collections.synchronizedMap (hashMap)
数组操作类Arrays
常用方法:查看api

泛型

集合大部分情况下存储的都是相同类型的数据
定义集合的类型，减少强制转换弓|起的ClassCastException异常，让程序在编译时
检查类型是否匹配
基本数据类型不能作为泛型(可使用包装类)

IP地址存储问题

当数据量极大时候，用list实现查询的效率很低

文件

File类

可以新建、删除、重命名文件和目录，不能访问文件内容本身

在windows下，路径是一个反斜杠

在linux，unix下，路径是一个正的斜杠

file常用方法

文件过滤器

 File parent =new File("E:/temp/");
//        String[] list = parent.list();
//        for (String string : list) {
//            System.out.println(string);
//          }
        
        String[] list2 = parent.list(new FilenameFilter() {
            
            @Override
            public boolean accept(File dir, String name) {
                if (name.endsWith(".txt")) {
                    return true;

                }
                // TODO Auto-generated method stub
                return false;
            }
        });
        for (String string : list2) {
            System.out.println(string);
          }

文件遍历

基本操作方式
获取文件列表.
判断是文件夹还是文件
如果是文件夹则递归查询

        File file = new File("E:/temp");
        if (!file.exists()) {
            System.out.println("不存在");
            return;
        }
        File[] listFiles = file.listFiles();     
        getFiles(listFiles);
    }
    
    private static void getFiles(File[] files) {
        for(File file:files) {
            if (file.isFile()) {
                System.out.println("文件"+file.getName());
            }else if (file.isDirectory()) {
                System.out.println("文件夹"+file.getName());
                File[] listFiles = file.listFiles();
                getFiles(listFiles);
            }
        }
        
    }

使用工具类操作方式
Paths
Files
walkFile Tree
FileVisitor

FileVisitResult是一个枚举类

try {
            Files.walkFileTree(Paths.get("e:","temp"),new SimpleFileVisitor<Path>(){
                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                    System.out.println(file);
                    return FileVisitResult.CONTINUE;
                }
                
                @Override
                public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                    System.out.println(dir);
                    return FileVisitResult.CONTINUE;
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }

IO流

流(Stream )代表的是程序中数据的流通
数据流是一串连续不断的数据的集合
在Java程序中，对于数据的输入/输出操作是以流(Stream)的方式进行的

用于访问文件的内容

根据流向:输入流和输出流
根据数据单位:
字节流

操作非文本文件，文本文件可能乱码，复制无问题

8位
InputStream OutputStream
字符流

用于操作文本文件

16位Unicode
Reader Writer
需要关闭流强制刷新缓冲区

常见流：

inputStream:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lpd8slMS-1635850227067)(C:\Users\Soul\AppData\Roaming\Typora\typora-user-images\image-20211022085814698.png)]

outputStream:

FileInputStream:

        File file = new File("E:/temp/abc.txt");
        FileReader fileInputStream=null;
        if (file.exists()) {
            try {
                 fileInputStream = new FileReader(file);
                //一个一个读取
//                int b;
//                while ((b=fileInputStream.read())!=-1) {
//                    System.out.print((char)b);
//                }
                //全部读取
                char[] buffer=new char[20];
                int len;
                while ((len=fileInputStream.read(buffer))!=-1) {
                    System.out.println(new String(buffer,0,len));

                }
                
                
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                if (fileInputStream!=null) {
                    try {
                        fileInputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

FileOutputStream:

FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter("E:/temp/asd.txt",true);
            String mString = "hello你好";
            fileWriter.write(mString);
            fileWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fileWriter!=null) {                
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

自动关闭文件

    //自动关闭资源的异常处理
    try(FileWriter fileWriter1 = new FileWriter("E:/temp/asd.txt",true)){
        String mString = "hello你好";
        fileWriter1.write(mString);
        fileWriter1.flush();
    }catch (Exception e) {
        e.printStackTrace();
    }

Reader

Writer

BufferedReader

BufferedWriter

//1.造文件
            File srcFile = new File("爱情与友情.jpg");
            File destFile = new File("爱情与友情3.jpg");
            //2.造流
            //2.1 造节点流
            FileInputStream fis = new FileInputStream((srcFile));
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2 造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            //3.复制的细节：读取、写入
            byte[] buffer = new byte[10];
            int len;
            while((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);

             bos.flush();//刷新缓冲区

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }

InputStreamReader

OutputStreamWriter

对象序列化

完成数据的持久化，将内存中的数据写入文件或数据库。以便于其它用户访问时能够恢复到对
象之前的数据信息。

对象序列化步骤

序列化：

        FileOutputStream fileOutputStream=null;
        ObjectOutputStream out=null;
        try {
            fileOutputStream = new FileOutputStream("E:/temp/stu.txt");
             out = new ObjectOutputStream(fileOutputStream);
             Student student = new Student("tom",18);
             out.writeObject(student);
             out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }

反序列化：

        File file = new File("E:\\temp\\stu.txt");
        FileInputStream fileInputStream = new FileInputStream(file);
        ObjectInputStream inputStream=new ObjectInputStream(fileInputStream);
        Object readObject = inputStream.readObject();
        if (readObject instanceof Student) {
            Student s = (Student) readObject;
            System.out.println(s.getName());
            System.out.println(s.getAge());    
        }

不希望被序列化的内容

在属性前面加transient修饰符

transient String pwd;

多个对象的序列化

读取配置文件

Properties

			Properties properties = new Properties();	
            properties.load(new FileInputStream("E:\\epoint\\eclipse-space\\Project1\\src\\db.properties"));
            Object object = properties.get("name");
            System.out.println(object);

ResourceBundle

        ResourceBundle sBundle=ResourceBundle.getBundle("db");
        String string = sBundle.getString("age");
        System.out.println(string);

迪杰斯特夫

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java基础

Java基础内容，培训9天总结
复制链接

扫一扫

专栏目录