前言：最近业务原因要将公司原有的平台的东西用java进行重构，就看了下java相关的，这个是java基本的额所有基础知识点，进行大概浏览目录，便于使用时候进行查找相关函数，这里大部分不对具体语法进行详细的描述。且去除了不太常用的图形界面相关的内容。
如果有什么遗漏之处还请补充。
- java常用工具类
- io相关：FileUtils，IOUtils
- 集合/数组相关：CollectionUtils, MapUtils, Lists, Maps, ArrayUtils
- 字符串相关: StringUtils, Splitter/Joiner
- 日期相关: DateUtils, DateFormtUtils, LocalDate
- 计时:StopWatch
- 应用包：log4j，junit，hutool，jsoup，lombok
- java基础
- 面向对象
- 变量
- 操作符号
- 控制流程
- 数组
- 类和对象
- 接口和继承
- 数字和字符串
- 日期
- 书籍
- java中级
- 异常处理
- try catch finally throws
- 异常分类
- Errors
- VirtualMachineError
- AWTError
- Exception
- RuntimeException
- IOException
- Errors
- Throwable类
- 通过catch Throwable类将所有的错误打印出来
try { { new FileInputStream(f); new FileInputStream(f); }catch (Throwable t) { catch (Throwable t) { t.printStackTrace(); t.printStackTrace(); } - 自定义类（通过继承Exception类进行定义）
- 通过catch Throwable类将所有的错误打印出来
- I/O
- 字节流
- FileInputStream是InputStream的子类
- 字符流
- FileReader
- FileWriter
- 缓存流（属于字符流，其他都是字节流）：
- 使用类BufferedReader
- 中文字符
- 常见编码：
- ISO-8859-1 ASCII, 数字和西欧字母
- GBK（所有汉字） gb2312（简体中文） BIG5（繁体中文）
- UNICODE 统一码
- 设置编码
- 常见编码：
- 数据流：DataInputStream，DataOutputStream
- 对象流:ObjectInputStream,ObjectOutputStream
- 输入输出流：常见的输入输出
- 字节流
- 集合框架
- List接口
- ArrayList
- 与数组相比，大小可随着内存自动的变化
- 常用方法：参考文档
- LinkedList
- queue实现
- stack实现
- ArrayList
- 泛型
- 不声明类型的泛型可存放任何存储对象，否则不能
List<Hero> genericheros = new ArrayList<Hero>(); <Hero> genericheros = new ArrayList<Hero>();
- 不声明类型的泛型可存放任何存储对象，否则不能
- 遍历
- 普通的for循环
- 迭代器：和js的next类似
//1.迭代器的一种写法 Iterator<Hero> it= heros.iterator(); <Hero> it= heros.iterator(); //从最开始的位置判断"下一个"位置是否有数据 //如果有就通过next取出来，并且把指针向下移动 //直到"下一个"位置没有数据 while(it.hasNext()){ (it.hasNext()){ Hero h = it.next(); Hero h = it.next(); System.out.println(h); System.out.println(h); } //2.迭代器结合for循环 for(Iterator<Hero> itreator = heroes.iterator();iterator.hasNext();) (Iterator<Hero> itreator = heroes.iterator();iterator.hasNext();) { Hero hero = (Hero) iterator.next(); Hero hero = (Hero) iterator.next(); } - 增强型for循环
for(Hero h:heros) (Hero h:heros)
- 二叉树
- 和js类似，结合list形成的数据结构
- HashMap
HashMap<String,String> dictionary = new HashMap<>(); <String,String> dictionary = new HashMap<>(); - HashSet：内部的值没有顺序
HashSet<String> names = new HashSet<String>(); <String> names = new HashSet<String>(); - Collection：接口
- collection
- set
- sortedset
- list
- queue
- deque
- set
- map
- sortedmap
- collection
- Collections：类，list等通过其中进行继承
- 其他
- HashSet vs ArrayList
- 前者无序，后者有序
- 前者不允许重复（主要是hashcode要不一样，比如相同值，分别用字符串和数值可以存入），后者允许重复
- ArrayList vs LinkedList
- HashMap vs HashTable 都是Map的实现
- 是否可以存放空值：HashMap可以存放null，HashTable不能存放null
- 是否是安全的类：HashMap不是线程安全的类，HashTable是线程安全的类（与vector类似，都是通过同步来进行保证）
- HashSet 无序
- LinkedHashSet 按照插入顺序
- TreeSet 从小到大排序
- 比较器（主要用在对于对象的比较）
- comparator一个可直接引用的对象
//引入Comparator，指定比较的算法 Comparator<Hero> c = new Comparator<Hero>() { <Hero> c = new Comparator<Hero>() { @Override @Override public int compare(Hero h1, Hero h2) { public int compare(Hero h1, Hero h2) { //按照hp进行排序 //按照hp进行排序 if(h1.hp>=h2.hp) if(h1.hp>=h2.hp) return 1; //正数表示h1比h2要大 return 1; //正数表示h1比h2要大 else else return -1; return -1; } } - comparable 是一个接口，通过其中定义的compareTo实现比较
package charactor; charactor; public class Hero implements Comparable<Hero>{ class Hero implements Comparable<Hero>{ public String name; public String name; public float hp; public float hp; public int damage; public int damage; public Hero(){ public Hero(){ } public Hero(String name) { public Hero(String name) { this.name =name; this.name =name; } //初始化name,hp,damage的构造方法 //初始化name,hp,damage的构造方法 public Hero(String name,float hp, int damage) { public Hero(String name,float hp, int damage) { this.name =name; this.name =name; this.hp = hp; this.hp = hp; this.damage = damage; this.damage = damage; } @Override @Override public int compareTo(Hero anotherHero) { public int compareTo(Hero anotherHero) { if(damage<anotherHero.damage) if(damage<anotherHero.damage) return 1; return 1; else else return -1; return -1; } @Override @Override public String toString() { public String toString() { return "Hero [name=" + name + ", hp=" + hp + ", damage=" + damage + "]\r\n"; return "Hero [name=" + name + ", hp=" + hp + ", damage=" + damage + "]\r\n"; } }
- comparator一个可直接引用的对象
- 聚合操作（其实就是类lamanda操作）
- HashSet vs ArrayList
- List接口
- 泛型
- 集合中的泛型
- 泛型的好处：是在使用的时候能够再进行调用
- 基本定义格式：
ArrayList<Hero> heros = new ArrayList<Hero>(); <Hero> heros = new ArrayList<Hero>(); ArrayList<Hero> heros2 = new ArrayList<>(); <Hero> heros2 = new ArrayList<>();
- 支持泛型的类
- 设计一个支持泛型的类时，应该在类上加上类型
package generic; generic; import java.util.HashMap; java.util.HashMap; import java.util.LinkedList; java.util.LinkedList; import charactor.Hero; charactor.Hero; import property.Item; property.Item; public class MyStack<T> { class MyStack<T> { LinkedList<T> values = new LinkedList<T>(); LinkedList<T> values = new LinkedList<T>(); public void push(T t) { public void push(T t) { values.addLast(t); values.addLast(t); } public T pull() { public T pull() { return values.removeLast(); return values.removeLast(); } public T peek() { public T peek() { return values.getLast(); return values.getLast(); } public static void main(String[] args) { public static void main(String[] args) { //在声明这个Stack的时候，使用泛型<Hero>就表示该Stack只能放Hero //在声明这个Stack的时候，使用泛型<Hero>就表示该Stack只能放Hero MyStack<Hero> heroStack = new MyStack<>(); MyStack<Hero> heroStack = new MyStack<>(); heroStack.push(new Hero()); heroStack.push(new Hero()); //不能放Item //不能放Item heroStack.push(new Item()); heroStack.push(new Item()); //在声明这个Stack的时候，使用泛型<Item>就表示该Stack只能放Item //在声明这个Stack的时候，使用泛型<Item>就表示该Stack只能放Item MyStack<Item> itemStack = new MyStack<>(); MyStack<Item> itemStack = new MyStack<>(); itemStack.push(new Item()); itemStack.push(new Item()); //不能放Hero //不能放Hero itemStack.push(new Hero()); itemStack.push(new Hero()); } }
- 设计一个支持泛型的类时，应该在类上加上类型
- 通配符
- ArrayList heroList<? extends Hero> 表示这是一个Hero泛型或者其子类泛型
ArrayList<? extends Hero> heroList = apHeroList; ArrayList<? extends Hero> heroList = apHeroList; //? extends Hero 表示这是一个Hero泛型的子类泛型 //heroList 的泛型可以是Hero //heroList 的泛型可以使APHero //heroList 的泛型可以使ADHero //可以确凿的是，从heroList取出来的对象，一定是可以转型成Hero的 Hero h= heroList.get(0); h= heroList.get(0); //但是，不能往里面放东西 heroList.add(new ADHero()); //编译错误，因为heroList的泛型 有可能是APHero .add(new ADHero()); //编译错误，因为heroList的泛型 有可能是APHero - ArrayList heroList<? super Hero> 表示这是一个Hero泛型或者其父类泛型
ArrayList<? super Hero> heroList = new ArrayList<Object>(); <? super Hero> heroList = new ArrayList<Object>(); //? super Hero 表示 heroList的泛型是Hero或者其父类泛型 //heroList 的泛型可以是Hero //heroList 的泛型可以是Object //所以就可以插入Hero heroList.add(new Hero()); .add(new Hero()); //也可以插入Hero的子类 heroList.add(new APHero()); .add(new APHero()); heroList.add(new ADHero()); .add(new ADHero()); //但是，不能从里面取数据出来,因为其泛型可能是Object,而Object是强转Hero会失败 Hero h= heroList.get(0); h= heroList.get(0); - 只取出，不插入，就使用？extends Hero
- 只插入，不取出，就使用？super Hero
- ArrayList heroList<? extends Hero> 表示这是一个Hero泛型或者其子类泛型
- 泛型转型
- 子类对象可以直接转换为父类对象
- 泛型是不可以相互转换的
- 假设可以转型成功
- 集合中的泛型
- Lambda
- 方法引用
- 引用静态方法
- 引用对象方法
//使用类的对象方法 TestLambda testLambda = new TestLambda(); testLambda = new TestLambda(); filter(heros, testLambda::testHero); (heros, testLambda::testHero); - 引用容器中的对象的方法
- 引用构造器
//匿名类 List list1 = getList(s); list1 = getList(s); //Lambda表达式 List list2 = getList(()->new ArrayList()); list2 = getList(()->new ArrayList()); //引用构造器 List list3 = getList(ArrayList::new); list3 = getList(ArrayList::new);
- 聚合操作
- Stream 和Collection结构化的数据不一样，Stream是一系列的元素，就像是生产线上的罐头一样，一串串的出来。
- 管道指的是一系列的聚合操作。
-
//普通方式 for (Hero h : heros) { (Hero h : heros) { if (h.hp > 100 && h.damage < 50) if (h.hp > 100 && h.damage < 50) System.out.println(h.name); System.out.println(h.name); } //聚合方式 heros heros .stream() .stream() .filter(h -> h.hp > 100 && h.damage < 50) filter(h -> h.hp > 100 && h.damage < 50) .forEach(h -> System.out.println(h.name)); forEach(h -> System.out.println(h.name)); //管道源stream或者Stream.of() //中间操作 filter 匹配 匹配 distinct 去除重复(根据equals判断) 去除重复(根据equals判断) sorted 自然排序 自然排序 sorted(Comparator<T>) 指定排序 (Comparator<T>) 指定排序 limit 保留 保留 skip 忽略 忽略 //转换为其他形式的流 mapToDouble 转换为double的流 转换为double的流 map 转换为任意类型的流 转换为任意类型的流 //结束操作 forEach() 遍历每个元素 () 遍历每个元素 toArray() 转换为数组 () 转换为数组 min(Comparator<T>) 取最小的元素 (Comparator<T>) 取最小的元素 max(Comparator<T>) 取最大的元素 (Comparator<T>) 取最大的元素 count() 总数 () 总数 findFirst() 第一个元素 () 第一个元素
- 方法引用
- 多线程：需要进行多多相关的练习
- 启动一个线程
- 创建多线程的方法：
- 继承thread类
- 实现runnable接口
- 匿名类的方式
- 创建多线程的方法：
- 常见线程方法
- 启动
- 暂停
- Thread.slepp()
- Thread.yield()
- 加入到当前线程
- t.join()
- 线程优先级
- t.setDaemon(true)
- 同步
- synchronized
- 线程安全的类
- HashMap vs HashTable（安全）
- StringBuffer (安全) vs StringBuilder
- ArrayList vs Vector（安全）
- 死锁
- 交互
- wait()
- notify()
- notifyAll()
- 线程池
- 线程的启动和结束都耗费大量时间和占用资源
- jdk自带类ThreadPoolExecutor
- 手动实现：线程池里面的问题
- Lock对象：与synchronized都可以达到线程锁死的目的，但前者是关键字，lock是一个接口
lock.lock();//线程启动进行占用 .lock();//线程启动进行占用 Thread.sleep(5000); .sleep(5000); lock.unlock();//线程结束进行释放 .unlock();//线程结束进行释放- synchronized是不占用到手不罢休，会一直试图占用下去
- lock.trylock(); 方法提供尝试占用，未占用就舍弃
- lock用await,signal,signalAll进行通知
Lock lock = new ReentrantLock(); lock = new ReentrantLock(); Condition condition = lock.newCondition(); condition = lock.newCondition(); condition.await(); .await();
- 原子访问；即不可中断的操作
- 启动一个线程
- JDBC
- 连接数据库
- 增，删，改
- 查询
- 预编译
- 特殊操作
- 事务
- ORM
- DAO
- 数据库连接池
- 异常处理
package jdbc;
jdbc;
import java.sql.Connection;
java.sql.Connection;
import java.sql.DriverManager;
java.sql.DriverManager;
import java.sql.SQLException;
java.sql.SQLException;
import java.util.ArrayList;
java.util.ArrayList;
import java.util.List;
java.util.List;
public class ConnectionPool {
class ConnectionPool {
List<Connection> cs = new ArrayList<Connection>();
List<Connection> cs = new ArrayList<Connection>();
int size;
int size;
public ConnectionPool(int size) {
public ConnectionPool(int size) {
this.size = size;
this.size = size;
init();
init();
}
public void init() {
public void init() {
//这里恰恰不能使用try-with-resource的方式，因为这些连接都需要是"活"的，不要被自动关闭了
//这里恰恰不能使用try-with-resource的方式，因为这些连接都需要是"活"的，不要被自动关闭了
try {
try {
Class.forName("com.mysql.jdbc.Driver");
Class.forName("com.mysql.jdbc.Driver");
for (int i = 0; i < size; i++) {
for (int i = 0; i < size; i++) {
Connection c = DriverManager
Connection c = DriverManager
.getConnection("jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8", "root", "admin");
getConnection("jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8", "root", "admin");
cs.add(c);
cs.add(c);
}
} catch (ClassNotFoundException e) {
catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
// TODO Auto-generated catch block
e.printStackTrace();
e.printStackTrace();
} catch (SQLException e) {
catch (SQLException e) {
// TODO Auto-generated catch block
// TODO Auto-generated catch block
e.printStackTrace();
e.printStackTrace();
}
}
public synchronized Connection getConnection() {
public synchronized Connection getConnection() {
while (cs.isEmpty()) {
while (cs.isEmpty()) {
try {
try {
this.wait();
this.wait();
} catch (InterruptedException e) {
catch (InterruptedException e) {
// TODO Auto-generated catch block
// TODO Auto-generated catch block
e.printStackTrace();
e.printStackTrace();
}
}
Connection c = cs.remove(0);
Connection c = cs.remove(0);
return c;
return c;
}
public synchronized void returnConnection(Connection c) {
public synchronized void returnConnection(Connection c) {
cs.add(c);
cs.add(c);
this.notifyAll();
this.notifyAll();
}
}
-
- 图形界面
- 网络编程
- IP地址端口InetAddress类
- socket
- SocketServer类
- Socket类
- 结束后都要进行close操作
- 多线程聊天
- 实践项目：基于swing和jdbc的桌面应用，次优先级
- java高级
- 反射机制
- 获取类对象;默认对类对象的静态方法进行初始化
String className = "com.company.Hero"; className = "com.company.Hero"; Class pClass1=Class.forName(className); pClass1=Class.forName(className); Class pClass2=Hero.class; pClass2=Hero.class; Class pClass3=new Hero().getClass(); pClass3=new Hero().getClass(); - 创建对象
//通过构造器创建一个对象 //构造器 Constructor c = pClass.getConstructor(); c = pClass.getConstructor(); //通过构造器进行实例化 hero h2 = (Hero) c.newInstance(); h2 = (Hero) c.newInstance(); //通过配置则是在开头进行读取 - 访问属性
- getField()
- getDeclaredField()
- 修改参考
//获取类Hero的名字叫做name的字段 Field f1= h.getClass().getDeclaredField("name"); f1= h.getClass().getDeclaredField("name"); //修改这个字段的值 f1.set(h, "teemo"); .set(h, "teemo"); //打印被修改后的值
- 调用方法
// 获取这个名字叫做setName，参数类型是String的方法 Method m = h.getClass().getMethod("setName", String.class); m = h.getClass().getMethod("setName", String.class); // 对h对象，调用这个方法 m.invoke(h, "盖伦"); .invoke(h, "盖伦");
- 获取类对象;默认对类对象的静态方法进行初始化
- 注解
- 基本内置注解
- @Override 表示重写
- @Deprecated 表示方法过期，不建议使用
- @SupperessWarnings 忽略警告信息
- SafeVarargs 使用可变参数，但参赛是泛型的情况下
- FunctionInterface 用于约定函数式接口，只用于只有一个函数
- 自定义注解
- 自定义注解@JDBCConfig
- 1. 创建注解类型的时候即不使用class也不使用interface,而是使用@interface
public @interface JDBCConfig @interface JDBCConfig - 元注解
- @Target({METHOD,TYPE}) 表示这个注解可以用用在类/接口上，还可以用在方法
- @Retention(RetentionPolicy.RUNTIME) 表示这是一个运行时注解，即运行起来之后，才获取注解中的相关信息，而不像基本注解如@Override 那种不用运行，在编译时eclipse就可以进行相关工作的编译时注解。
- @Inherited 表示这个注解可以被子类继承
- @Documented 表示当执行javadoc的时候，本注解会生成相关文档
- @Repeatable 使得注解在同一个位置可以被重复多次
- 解析注解
- 1.通过反射，获取这个DBUtil这个类上的注解对象
JDBCConfig config = DBUtil.class.getAnnotation(JDBCConfig.class); config = DBUtil.class.getAnnotation(JDBCConfig.class); - 2.通过其方法，获取各个注解元素的值
String ip = config.ip(); ip = config.ip(); int port = config.port(); port = config.port(); String database = config.database(); database = config.database(); String encoding = config.encoding(); encoding = config.encoding(); String loginName = config.loginName(); loginName = config.loginName(); String password = config.password(); password = config.password();
- 1.通过反射，获取这个DBUtil这个类上的注解对象
- 仿hibernate注解
- 1.配置hbm.xml方式
- 2.注解方式
- 注解分类
- 1.按照作用域分
根据注解的作用域@Retention，注解分为 @Retention，注解分为 RetentionPolicy.SOURCE： Java源文件上的注解 .SOURCE： Java源文件上的注解 RetentionPolicy.CLASS： Class类文件上的注解 .CLASS： Class类文件上的注解 RetentionPolicy.RUNTIME： 运行时的注解 .RUNTIME： 运行时的注解 - 2.按照来源分
1. 内置注解 如@Override ，@Deprecated 等等 内置注解 如@Override ，@Deprecated 等等 2. 第三方注解，如Hibernate, Struts等等 第三方注解，如Hibernate, Struts等等 3. 自定义注解，如仿hibernate的自定义注解 自定义注解，如仿hibernate的自定义注解
- 1.按照作用域分
- 基本内置注解
- 反射机制
- java应用
- log4j 可以灵活的把日志信息输出到控制台，日志文件等地方
- junit 白盒单元测试，类似于mocha
- hutool 一个实用工具类库
- jsoup xml/html解析工具
- lombok 自动生成setter/getter相关接口
- 前端部分
269
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
