javase基础
程序员文章站
2024-03-23 14:50:34
...
#java13(10分钟)
1.特点
* 开源 跨平台(jvm) 多线程 面向对象 分布式 解释性语言 垃圾回收机制
2.配置环境
* JAVA_HOME: E:\Java\jdk1.8.0_60
* PATH: %JAVA_HOME%\bin;
* java -version java javac
3.编译和文件
* jre: java运行环境
* jdk: java软件开发包
* .java .class
* javac hello.java java hello
4.jshell的使用
#注释 关键字 标识符
1.注释类型
* // /* / /* */
2.标识符
* 数字不能开头 不能关键字 英文,数字,$,_组合
* HelloWorld{} testAdd() var NUM
#常量 变量
1.6种常量类型
* 布尔常量 true
* 整数常量 3
* 浮点数常量 1.1
* 字符常量 ‘a’
* 注意: ‘ab’ ‘’ 不是字符
* 字符串常量 “s”
* null常量 null
2.变量
* 右侧数值的范围不能超过左边数据类型的取值范围
* 可以直接打印字符,布尔类型不能数据转换
* byte char short 运算会自动转换为int类型
#数据类型
1.8种基本数据类型
* byte short char int long(L) float(F) double boolean
2.强制类型转换(高转低)
* int num = (int)100L
#运算符
1.运算符必须要有结果
* + - * / % ++ –
* += -= /= *= %= =
* >= <= > < != ==
* ! || &&
* 短路运算
* ? :
#流程语句
1.顺序语句
{}
2.选择语句
* if(){}
* if(){} else{}
* if(){} else if(){} else{}
* switch(表达式){
case 常量值1: 语句体1; break;
default: 语句体1; break; }
* 注意: 穿透
3.循环语句
* while(判断语句){}
* do{}while(判断语句)
* for(int i=0;i<10;i++){}
* 循环嵌套,笛卡尔积
4.关键字
* continue break return
5.死循环
* for(;;)
* while(true){}
#数组
1.存放多种数据,类型必须统一,是引用类型,数组长度在运行过程长度不可改变
* int[] arr = new int[3]
* int[] arr1 = new int[]{5,2}
* int[] arr2 = {12,2}
* arr.length arr[i]
2.数组遍历
int[] arr = {1,2};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
3.常见错误和扩展
* null指针异常 越界异常
* 数组作为引用,参数和返回值都是地址值
4.Arrays工具类
* public static <T> List<T> asList(T... a) 数组变集合,不能改变集合长度
* boolean equals(int[] a,int[] b) 数组是否相等
* void fill(int[] a,int val) 指定填充数组,会替换掉数组中原来的元素
* void sort(int[] a) 串行排序
* int binarySearch(int[] a,int key) 二分查找
* Arrays.toString(Object[] array) 变成字符串(重写)
#方法
1.方法重载
* 方法名相同,参数列表不同(顺序 参数类型 参数个数),跟返回值无关
修饰符 返回值类型 方法名称(参数类型 参数名称 ...) {
方法体
return 返回值
}
* return后面的返回值,必须跟方法的返回值类型保持对应
* 单独调用 打印调用 赋值调用
* 参数局部变量,调用一定被赋值
2.可变形参
* 数据类型 ...变量名,底层是数组
* 传递的数据可以0个或者多个,可变参数的实参可以为一维数组类型
#小知识
1.默认值
* 0.0 ‘\u0000’ false null 0
2.内存存放
* 栈内存: 方法 局部变量
* 堆内存: new出来的对象
* 方法区: 全局变量 static 常量池
* 两个引用指向同一对象
3.基本类型参数传递值不变,引用类型值改变
4.导包
* import *
5.权限修饰符
* public protected 默认 private
6.类的赋值顺序
* 默认初始化 - 显示初始化|构造代码块 - 构造器赋值 - 通过对象.方法赋值
7.==和equals()
* ==基本类型是值,引用类型是地址值
* equals()引用类型地址值,重写是值
8.transient
* 成员变量不参与序列化
#面向对象(10分钟)
1.特点
* 封装 继承 多态
2.类和对象
* 成员变量 成员方法的区别
* 内存地址不同 类的位置不同 默认值不一样 作用范围不一样 生命周期不一样
public class Stu {
private String name;
private int age;
}
Stu s = new Stu()
3.匿名对象
* 一般不会给匿名对象赋予属性值,两个匿名对象永远都不可能是同一个对象,可以做参数和返回值
* new Stu().x()
4.javaBean
* 类是公共 有一个无参构造器 有属性提供getX()和setX()方法,还要实现序列化
#封装
1.private类属性私用
* void setXX(){this.xx = xx}
* int getXX(){return xx}
2.this关键字
* 区别局部变量和成员变量重名
* 调用成员属性或者构造方法
3.构造方法
* 给对象的数据进行初始化的
* public Person{}
#代码块
1.静态代码块
* 加载的很多配置文件等资源,优先main方法
* static{}
2.构造代码块
* 构造代码块在创建对象时被调用,每次创建对象都会调用一次
* {}
3.普通代码块
* 方法定义,限定变量生命周期
* {}
#static
1.类成员变量 类成员方法
* stu.x stu.x()
2.如何使用static
* 属性可以被共享 操作静态属性方法 工具类
3.注意事项
* 静态方法中没有this这个对象
* 对象成员属性可以访问静态成员,静态成员可以访问静态
#继承
1.特点
* 子类继承父类的非私有的成员,私有成员可以通过父类中提供的setter和getter方法进行间接的访问
* 如果子类中出现了和父类同名的成员变量和成员方法时,父类的成员变量会被隐藏,父类的成员方法会被覆盖,需要使用super来引用
* 子类不能继承获得父类的构造方法，但是可以通过super关键字来访问父类构造方法
public class Person {}
public class Stu extends Person{}
2.继承的执行顺序
* 静态代码块Fu 静态代码块Zi 构造代码块Fu 构造方法Fu 构造代码块Zi 构造方法Zi
3.三种变量重名
* num super.num this.num
4.重写
* 继承关系中,方法的名称一样,参数列表也一样,返回值可以子父类
* 子类方法的权限必须大于等于父类方法的权限修饰符,父类私有方法不能重写
5.构造方法
* 先使用父类的构造方法,再子类的构造方法
* 子类可以使用super调用父类,必须在子类的构造方法第一个
6.成员变量
* 同名就近原则
* 局部变量 - 子类成员变量 - 父类成员变量
7.成员方法
* 创建对象是谁,就优先用谁
8.super
* 访问父类的成员变量和成员方法,或者构造方法
9.继承特点
* java单继承,多层继承
#多态
1.继承或者实现是多态的前提
* 父类引用指向子类对象
* 父类名称 对象名 = new 子类名称()
* 接口名称 对象名 = new 实现类名称()
2.特点
* 成员变量,编译看左边运行看左边
* 静态方法编译看左边,运行看左边
* 成员方法编译看左,运行看右
3.向上转型和向下转型
* 向上转型(小转大)
* 作用就是限制对特有功能的访问
* 向下转型(大转小)
* 子类名称 对象名 = (子类名称)父类对象
* object instanceof class
#抽象类
1.特点
* 抽象类,可以有构造方法给子类创建对象用
* 抽象类不能创建对象,必须用子类来继承抽象父类
* 抽象类的子类,必须重写所有抽象方法
* 成员变量:既可以是变量,也可以是常量
* 不一定包含抽象方法,但抽象方法的类必定是抽象类
public abstract class Ani {
public abstract void eat();
}
#接口
1.各个版本特点
* java7: 常量 抽象方法
* java8: 默认方法 静态方法
* java9: 私有方法
public interface My{
public abstract void menthod1();
public default void method2(){};
public static void method3(){};
private void method4(){};
private static void method5(){};
}
public class me implements my {
}
2.接口默认方法
* 接口默认方法,可以通过接口实现类对象,直接调用
* 接口默认方法,可以被接口实现类进行覆盖重写
3.接口静态方法
* 不能通过接口实现类的对象来调用接口当中的静态方法
* 通过接口名称直接调用静态方法
* M.methodStatic();
4.接口私有方法定义
* 普通私有方法
* 解决多个默认方法重复代码
* 静态私有方法
* 解决静态方法直接的重复代码
5.接口成员变量
* public static final 数据类型 常量名称 = 数据值
* public static final int num = 10
6.接口的注意事项
* 没有静态代码块或者构造方法
* 如果实现类所实现的多个接口当中,存在重复的抽象方法,只需要覆盖重写一次即可
* 如果实现类没有覆盖重写所有接口当中的所有抽象方法,那么实现类就必须是一个抽象类
* 如果实现类实现的多个接口当中,存在重复的默认方法,那么实现类一定要对冲突的默认方法进行覆盖重写
* 相同方法,继承优先接口
#final
1.修饰类
* 类不能被继承
2.修饰方法
* 修饰方法不能被重写
3.修饰局部变量
* 基本类型就是常量,引用类型就是地址值
4.可以用来修饰一个成员变量
* 由于成员具有默认值,用了final不能再给默认值
* 赋值构造方法赋值或者直接赋值
* final int x
#内部类
1.成员内部类
修饰符 class 外部类名称 {
修饰符 class 内部类名称 {
}
}
* 使用: 外部类.内部类 对象名 = new 外部类名称().new 内部类名称()
* 内部类的同名变量访问: this.num outer.this.num num
2.局部内部类
修饰符 class 外部类名称 {
修饰符 返回值类型 外部类方法名称(参数列表) {
class 局部内部类名称 {}
}
inner inner = new inner()
inner.methodiNeer()
}
* 局部内部类,如果希望访问所在方法的局部变量,那么这个局部变量必须是final
3.匿名内部类
* 父类接口 对象名 = new 子类接口(){
覆盖重写所有的抽象方法
}
* 注意事项
* 匿名对象,在调用方法的时候只能调用唯一一次,如果希望同一个对象,调用多次方法,那么必须给对象起个名字
* 匿名内部类是省略了类或者子类名称,匿名对象是省略对象名称
#常见api
1.Objects
* public static boolean equals(Object a,Object b) 1.7,避免null指针异常
* public static T requireNoneNull(T obj,String messge) 查看对象引用对象是否为null
2.Object
* public boolean equals(Object obj) 是否相等
* public int hashCode() 哈希code值
* public String toString() 字符串表示
* void wait() 线程进入等待状态
* void wait(long timeout) 线程指定毫秒数醒来
* void notify() 唤醒等待单个线程
* void notifyAll() 唤醒等待的所有线程
3.Scanner(键盘录入)
* new Scanner(System.in) 构造方法
* nextInt() 输入整数
* next() 输入字符串
* nextLine() 输入字符串(可有空格)
* hasNextInt() 判断输入的数是否整数
4.Random(随机)
* new Random() 构造方法
* nextBoolean() 随机返回true
* nextInt() 随机整数
* nextInt(10) 随机0-9
* nextDouble() 随机(0,1)的小数
5.Math(工具类)
* Math.max( , ); 计算最大值
* Math.min( , ); 计算最小值
* Math.ceil(-10.1) 返回大的值
* Math.floor(-10.1) 返回最小值
* Math.random() 小于1大于0的double类型的数
* Math.round(10.1) 四舍五入
6.Date(时间类)
* new Date() 12:22:23 cst 2019
* long getTime() 获取对应毫秒值,1970.1.1开始算
* void setTime() 毫秒转日期,1970.1.1开始算
* String toString() 重写了toString
7.DateFormat(时间格式化抽象类)
* String format(Date date) 日期格式化为字符串
* Date parse(String source) 字符串格式日期
8.SimpDateFormat(时间格式化实现类)
* public Date parse(String source) throws ParseException 字符串转换日期
* String format(Date date) 日期转换字符串
SimpDateFormat sdf = new SimpDateFormat("YYYY-MM-dd HH:mm:ss")
String s = sdf.format(new Date())
9.Calendar(日历抽象类)
* static Calendar getInstance() 创建日历类对象
* public int get(int field) 返回给定日历字段的值
* public void set(int field,int value) 将给定的日历字段设置为给定值
* public abstract void add(int field, int amount) 为给定的日历字段添加或减去指定的时间量
* public Date getTime() 返回一个表示此Calendar时间值的Date对象
* LocalDate LocalTime LocalDateTime(jdk1.8提供更简单的时间类)
10.System(系统类)
* public static long currentTimeMillis() 返回以毫秒为单位的当前时间,1970.1.1开始算
* public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
* static void setOut(PrintStream out) 改变输出地方
11.ArrayList(.fori .forr)
* 线程不安全,效率快,查询快,底层数组
* new ArrayList<>() 构造方法
* boolean add(Element e) 添加
* void add(int index, Element e) 指定添加
* E remove(int index) 删除
* void clear() 清空
* E get(int index) 获取
* E set(int index, E element) 设置值
* int size() 长度
* boolean isEmpty() 是否为空
* Object[] toArray() 变成数组
* boolean contains(Object o) 是否包含元素
* int indexOf(Object o) 对象找索引
* int lastIndexOf(Object o) 最后的所在位置
12.String(字符串)
* 一旦创建不会改变,其实就是字节数组或者字符数组,常量池共享
* String s = 'x' String(char[] arr) String(byte[] arr,String charsetName)
* String(char[] value,int offset,int count) 字符数组一部分转换为字符串
* int length() 长度
* boolean equals(Object obj) 字符串是否相等
* boolean equalsIgnoreCase(Object obj) 忽视大小写
* char charAt(int index) 获取指定索引的字符
* int indexOf(int i,int number) 查找字符出现在字符串第一次出现的位置,不存在返回-1
* int indexOf(String s) 查找字符串在指定字符串的索引
* String substring(int i) 截取字符串
* String substring(int begin,int end) 截取字符串[begin,end)
* String trim() 去掉两端空格
* String toLowerCase() 全部小写
* String toUpperCase() 全部大写
* String replace(String old,String new) 替换
* String[] split(String regex) 分割字符串
* \\.
* char[] toCharArray() 将字符串转成字符数组
* byte[] getBytes() 字符串变成字节数组
* boolean startsWith(String str) 以什么字符串开头
* boolean endsWith(String str) 以什么字符串结尾
* boolean contains(str) 字符串中是否包含某一个子串
* boolean isEmpty() 内容是否为空
* static String valueOf(int) 将基本数据类型转成字符串
* int compareTo(string) 按字典顺序比较
* boolean mathes(String regex) 字符串匹配正则
13.StringBuilder(字符串缓存区)
* 字符串缓冲区,字符串可以改变,线程不安全,效率高
* StringBuilder() StringBuilder(String str) 构造方法
* public StringBuilder append(...) 添加任意类型数据的字符串形式，并返回当前对象自身
* public String toString() 将当前StringBuilder对象转换为String对象
* StringBuffer delete(int start,int end) 删除
* StringBuffer insert(int offset,xxx) 插入
* StringBuffer reverse() 反转
* StringBuffer replace(int start,int end,String str) 替换
* 相互转换
* String() += toString() StringBuilder转换String
* StringBuilder() append() String转换StringBuilder
14.Collections(集合工具类)
* shuffle(Collection) 随机排序
* sort(list<T>,Comparator<? super T>) 冒泡排序
* javabean对象实现Comparable接口,重写compareTo()
* Comparator接口,重写compare(Integer o1,Integer o2)
* binarySearch(Collection,Object) 二分查找法
* reverse() 反转
* fill(List list,Object o) 用对象o替换集合list中的所有元素
* copy(List m,List n) 将集合n中的元素全部复制到m中,并且覆盖相应索引的元素
* public static <T> boolean addAll(Collection<T> c,T...elements) 往集合添加一些元素
#包装类
1.简单类型转换成包装类型
* Integer Character Long Short Double Float Boolean
2.自动装箱和自动拆箱
* Integer i3 = 8
* int i5 =i3
3.类型转换
* Integer(int value) Integer(String s) 基本类型 - 包装类型
* new Integer().intValue() 包装类型 - 基本类型
* Integer.toString() String.valueOf() c+"" 基本类型|包装类型转换String
* Integer.parseInt("") Integer.valueOf(int i) Integer.valueOf(String s) 字符串转为基本类型
#集合(10分钟)
1.长度可以改变,存储都是对象
Collection接口
List接口(有序,允许重复,有索引) Set接口(无序,不允许存储重复元素,无索引)
Vector ArrayList LinkedList TreeSet HashSet LinkHashset(有序)
2.Collection集合
* public boolean add(E e) 添加
* public boolean addAll(Collection<? extends E> c) 添加整个集合元素
* public void clear() 清空
* public boolean remove() 删除
* public boolean retainAll(Collection<?> c) 保留交集
* public boolean contains() 包含
* public boolean isEmpty() 是否为空
* public int size() 长度
* public Object[] toArray() 变成数组
* public String toString() 重写toString [,]
* Iterator<E> iterator() 获取迭代器
3.迭代器Iterator接口
* 取出下一个元素,指针向后移动
Iterator<String> it = c.iterator();
while(it.hasNext()){
String s = it.next();
}
* ListIterator迭代器的add/remove对集合进行增删改,只能list集合用
4.增强for循环
* for(元素的数据类型 变量: 集合或者数组){}
5.泛型
* 避免类型转换,运行期异常转换为编译器异常
* 泛型类定义
pubilc class ArrayList<E>{
private E name;
public E getName(){return name}
public void setName(E a){this a=a}
//1.泛型方法
public<E> void method2(E e){}
//2.泛型静态方法
public static<S> void method2(S s){}
}
* 泛型接口
public interface MyG<E>{
public abstract void add(E e);
}
* 类实现接口同时,指定泛型接口
public class GenerInter implements Gen<String>{}
* 类实现含有泛型的接口,接口使用什么类型,类就用什么类型
public class GenerInter<T> implements Gen<T>{}
* 泛型通配符 ?
* extend泛型上限(E类型的子类/本身) super下限(E类型的父类/本身) 是看泛型的类型
6.数据结构
* 栈: 先进后出
* 队: 先进先出
* 数组: 查询快,增删慢
* 链表: 增删快,查询慢
* 红黑树: 查询速度非常快
7.List接口
* 有序 允许重复 有索引
* void add(int index,E element)
* E get(int index)
* E remove(int index)
* E set(int index,E element)
8.Vector
* void addElement(E obj) 添加
* Enumeration elements() 遍历
9.LinkedList
* 查询慢 增删快 有序有索引
* public void addFirst(E e) 将指定元素插入此列表的开头
* public void addLast(E e) 将指定元素添加到此列表的结尾
* public E getFirst() 返回此列表的第一个元素
* public E getLast() 返回此列表的后一个元素
* public E removeFirst() 移除并返回此列表的第一个元素
* public E removeLast() 移除并返回此列表的后一个元素
* public E pop() 删除最后一个元素
* public void push(E e) 类似addFirst(E e)
* public boolean isEmpty() 如果列表不包含元素，则返回true
10.Set接口
* 不允许存储重复元素,没有索引,跟Collection方法一样
11.HashSet
* 底层哈希表,查询速度快,数组+链表+红黑树,存取不一致
* 存储自定义类型元素重写equals()和hashCode(),其实是判断hash值是否相同
* LinkedHashSet
* 存储一致,不允许重复集合,没有索引
12.Map接口
* 键值对集合,键不能重复,值可以重复
* public V put(K key, V value) 把指定的键与指定的值添加到Map集合中
* public V remove(Object key) 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值
* public V get(Object key) 根据指定的键,在Map集合中获取对应的值
* public Set<K> keySet() 获取Map集合中所有的键,存储到Set集合中
* public Set<Map.Entry<K,V>> entrySet() 获取到Map集合中所有的键值对对象的集合(Set集合
* public boolean containskey(Object key) 集合是否包含指定的键
* public boolean containsValue(Object value) 集合是否包含指定的键
* public String toString() 自己重写toString {age=13}
* 遍历
for(String key: map.keySet()){
Integer value = map.get(key)
System.out.printLn(key+"="+value)
}
Map<String,Integer> map = new HashMap<>()
map.put("x",12)
Set<Map.Entry<String,Integer>> set = map.entrySet()
Iterator<Map.Entry<String,Integer>> it = set.iterator()
while(it.hashNext()){
Map.Entry<String,Integer> entry = it.next()
String key = entry.getKey()
Integer value = entry.getValue()
System.out.printLn(key+"="value)
}
13.HashMap
* 查询快,不同步,多线程,不安全
* LinkHashMap子类
* 有序,增删慢
14.Hashtable(代码)
* 线程安全,速度慢,不能存储null ,单线程
* Properties
* 键和值都是字符串
* public Properties()
* public Object setProperty() 设置一对属性
* public String getProperty() 通过键获取值
* public Set<String> stringPropertyNames() 键的集合
* void store(OutputStream out,String comments) 写入配置数据
* void load(InputStream instream) 读取配置数据
Properties pros = new Properties()
pros.load(new FileInputStream("jdbc.properties"))
String user = pros.getProperty("user")
15.jdk9.0新特性
* static <E> list<E>|map<E>|set<E> of(E...elements)
* 当集合中元素个数确定了,不在改变使用
* of只适用list接口,Set接口,Map接口,不适用接口的实现类
* of返回值是不能改变的集合,集合不再使用add,put,会抛出异常
* Set接口和Map接口在调用of方法的时候,不能有重复的元素,不然会抛出异常
#异常
1.异常体系
Throwable
Error Exception(编译型异常)
RuntimeException
NullPointerEeception IOException ClassNotFoundException
2.异常处理
* try{检测代码} catch(异常类型){} finally{最终执行代码}
* throws 异常类型
3.手动抛出异常
* throw new RuntimwException("输入非法")
* 运行期没用必要处理,一般修改异常,让程序不再抛出运行期异常,直接结束程序
4.自定义异常
public class MyException extends Exception{
//1.需要空参
public MyException(){}
//2.需要实参调用
public MyException(String messge){
super(message)
}
}
#File(5分钟)
1.描述文件的和目录信息
* File(String path) 构造方法
* boolean mkdir() 创建文件夹
* boolean mkdirs() 创建多个文件夹
* boolean createNewFile() 创建文件
* boolean delete() 删除文件
* isDirectory() 是否是目录
* boolean isFile() 是否是文件
* boolean exists() 是否存在文件或者目录
* String[] list() 所有文件名
* File[] listFiles() 文件目录
* File[] listFiles(FileFilter file) 文件目录
* File[] listFiles(FilenameFilter String) 文件目录
* boolean renameTo(File dest) 重命名
* long lastModified() 最后修改时间
* String getName() 获取名字
* long length() 文件的大小
* String getAbsolutePath() 获取绝对路径
* String getPath() 获取相对路径
for(File tf:fArr){
if(tf.isFile()){}
}
Date d1 = new Date(f1.lastModified())
SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss")
sdf.format(d1)
2.FileFilter文件过滤器接口
* boolean accept(File pathname)
File[] files = dir.listFiles(new FileFilter){
public boolean accept(File pathname){
return pathname.isDirectory()||pathname.getName().toLowerCase().endWith(".java")
}
}
3.FilenameFilter文件名过滤器接口
* boolean accept(File dir,String name)
File[] files = dir.listFiles(new FilenameFilter){
public boolean accept(File dir,String name){
return new File(dir,name).isDirectory()||name.toLowerCase().endWith(".java")
}
}
#IO
1.InpuStream抽象类
* FileInputStream字节文件输入流
* FileInputStream(String name) 构造方法
* FileInputStream(File file) 构造方法
* int read() 读取单个字节,不存在返回-1
* int read(byte[] b)
* int read(byte[] b,int off,int len)
* int available()
* BufferInputStream字节缓存输入流
* public BufferedInputStream(InputStream in)
* DataInputStream数据输入流
* DataInputStream(InpuStream f)
* int readInt()
* ObjectInputStream对象反序列中
* 对象要支持Serializable
* ObjectInputStream(InpuStream in)
* void readObject(Object obj)
2.OutputStream抽象类
* FileOutputStream文件输出流
* 不存在文件会自动创建
* FileOutputStream(String name) 构造方法
* FileOutputStream(File file) 构造方法
* FileOutputStream(String name,boolean append) 文件追加
* void write(int b) 写入字节,默认转换字符
* void write(byte[] b ,int index,int len)
* void write(byte[] b) b.length写入
* void close()
byte[] bytes2 = "你好".getBytes()
file.write(bytes2)
* BufferOutputStream
* public BufferedInputStream(OutputStream out)
* DataOutputStream数据输出流
* DataOutputStream(OutputStream f)
* int writeInt(int v)
* ObjectOutnputStream对象序列流
* ObjectInputStream(InputStream in)
* Object WriteObject()
3.Reader抽象类
* FileReader字符文件输入流
* FileReader(String filename)
* FileReader(File file)
* int read()
* int read(char[] cbuf)
* void close
* BufferedReader
* BufferedReader(Reader read)
* int read()
* int read(char[] cbuf,int off,int len)
* String readLine() 不存在返回null
* InputStreamReader字节转换为字符流
* InputStreamReader(InputStream in)
* InputStreamReader(inputStream,String charsetName)
4.Writer
* FileWriter
* FileWriter(File file)
* FileWriter(String filename)
* void write(int c) 会转换字符
* void write(char[] cbuf,int off,int len)
* void write(char[] cbuf)
* void write(String str)
* void write(String str,int off,int len)
* BufferedWriter
* BufferedWrite(Writer out)
* void write(int c)
* void write(char[] cbuf,int off,int len)
* void write(char[] cbuf)
* void write(String str)
* void write(String str,int off,int len)
* void newLine() 换行符
* OutputStreamWriter字符转换字节流
* OutputStreamWriter(OutputStream out)
* OutputStreamWriter(OutputStream out,String charsetName)
* PrintStream
* 打印数据并且自动刷新
* PrintStream(File file)
* PrintStream(String filename)
* PrintStream(OutputStream out)
* void print(String s) 原样输出
5.拷贝(代码)
inputStream fis = new FileInputStream("c:\\a.txt")
FileOutputStream fos = new FileOutputStream("c:\\b.txt")
int res =0;
while((res=fis.read())!=-1)){
fos.write(res)
}
fos.close();
fis.close();
inputStream fis = new FileInputStream("c:\\a.txt")
FileOutputStream fos = new FileOutputStream("c:\\b.txt")
byte[] bArr = new byte[1024*8]
//有效个数
int len =0;
while((res=fis.read(bArr)!=-1)){
fos.write(bArr,0,len)
}
fos.close();
fis.close();
* utf-8 3个字节一个中文,GBk 两个字节一个中文
* 换行 window -> \r\n linux -> /n mac -> /r
6.jdk9.0和jdk7.0处理流异常
FileInputStream fis = new FileInputStream("c:\\9.0")
FileOutputStream fos = new FileOutputStream("d:\\1.jpg")
try(fis;fos){
int len = 0;
while((len = fis.read()!=-1)){
fos.write(len)
}
}catch(Exception e){
...
}
try{
FileInputStream fis = new FileInputStream("c:\\7.0")
FileOutputStream fos = new FileOutputStream("d:\\1.jpg")
int len = 0;
while((len = fis.read()!=-1)){
fos.write(len)
}
}catch(Exception e){
...
}
7.commons_IO文件工具类
* commons-io.jar包
* 常用方法
* static String readFileToString() 读取文件变为字符串
* static void writeStringToFile(File file,String data) 将内容写入文件中
* static void copyFile(File srcFile,File destFile) 文件复制
* static void copyDirectoryToDirectory(File srcDir,File destDir) 文件夹复制以及下面的
#多线程Thread(10分钟)
1.进程 线程 并发 并行 单核cpu 多核cpu
* 多个事件交替执行 多个事件同时执行
* 一个java至少有5个线程
class MyThead extend Thread{
public void run(){
System.out.print(i)
}
}
public class ThreadTest{
public static void main(String[] args){
MyThread t1 = new MyThread()
t1.start()
System.out.print(Thread.currentThread().getName())
}
}
2.线程常用方法
* public Thread() 构造方法
* public Thread(String name) 构造方法
* public Thread(Runnable target) 构造方法
* void start() 启动线程
* void run() 线程被调用
* String getName() 返回线程名称
* void setName() 设置线程名称
* static Thread currentThread() 返回当前线程
* yield() 释放当前cpu
* join() 加入线程,a加入执行完才到b
* public static void sleep(1000) 睡眠线程,睡眠结束继续执行
* setDaemon() 设置守护线程,开启前调用
* boolean isDaemon() 是否守护线程
3.线程优先级
* getPriority() 返回线程优先值
* setPriority(int newPriority) 改变线程的优先级
* MAX_PRIORITY MIN_PRIORITY NORM_PRIORITY
4.Runnable(代码)
class myRun implements Runnable{
public void run(){}
}
public class ThreadTest{
public static void main(String[] args){
myRun m = new myRun()
Thread t1 = new Thread(m)
t1.start()
}
}
* 没有类的单继承局限性,更适合多个数据来共享数据
5.线程生命周期
* 新建 - 就绪 - 运行 - 阻塞(睡眠 - 等待) - 死亡
6.线程安全问题
* 对同一个数据进行操作,有安全问题
* 同步代码块
* synchronized(锁){共享数据代码} obj对象
* 同步方法
* public synchronized void show(){} 锁是this,静态
* 静态同步方法
* public static synchronized void show(){} class文件对象
* lock锁
* private final ReentrantLock lock = new ReentrantLock()
* lock() unlock()
* 死锁
7.线程池
* 多线程的容器,减取频繁创建对象的操作,用完归还线程
* 常用方法
* static ExecutorService newFixedThreadPoll(int i)
* ExecutorService接口
* 常用方法
* submit(Runnable task) 提交任务
* void shutdown() 销毁
ExecutorsService es = Executors.newFixedThreadPoll(2)
es.submit(new RunableImpl())
* Callable<V>接口
* v Call() 返回接口相同的值
8.ThreadLocal
* 提供线程局部变量(哪个线程存储的数据,只有那个线程使用)
* void set(T value) 通过当前线程添加
* T get() 通过当前线程获取
* void remove() 通过当前线程移除
#网络编程
1.udp
* 无连接通信协议,数据发送端和接受端不建立连接,消耗资源小,通信效率高,不安全
2.Tcp
* 面向连接的通信协议,每次要新建连接,再发送数据,客户端向服务端发送请求,面向三次握手
* 第一次握手,客户端向服务端发送请求,等待服务器确认
* 第二次握手,服务端向客户端发送一个响应,通知客户端收到连接请求
* 第三次握手,客户端再次向服务端发送确认信息,确认连接
* 第一次挥手,客户端与服务端交谈结束之后,客户端要结束会话,对服务器说我要关闭
* 第二次挥手 服务器收到客户端的消息,确认客户端要关闭连接
服务器确认后,要等待一段时间,因为客户端有可能还要话要说
* 第三次挥手 客户端说完话后,就关闭连接了
* 第四次挥手 客户端收到服务端的消息说,已收到你要关闭的消息,
服务端收到客户端的确认,也进行close
3.ServerSocket服务端
* ServerSocket(int port)
* Socket accept()
* void close()
* InputStream getInputStream()
* OutputStream getOutputStream()
* void shutdownOutput()
public class TCPServer {
public static void main(String[] args) throws IOException {
//1.创建服务器ServerSocket对象,指定的端口号
ServerSocket server = new ServerSocket(8888);
//2.使用accept,监听并获取到请求的客户端Socket对象
Socket socket = server.accept();
//3.使用Socket对象中的方法getInputStream,获取网络字节输入流InputStream对象
InputStream is = socket.getInputStream();
//4.使用网络字节输入流InputStream对象中的方法read,读取客户端发送的数据
byte[] bytes = new byte[1024];
int len = is.read(bytes);
System.out.println(new String(bytes,0,len));
//5.使用Socket对象中的方法getOutputStream,获取网络字节输出流OutputStream对象
OutputStream os = socket.getOutputStream();
//6.网络字节输出流OutputStream对象中的方法write,给客户端回写数据
os.write("收到,谢谢".getBytes());
//7.释放资源
socket.close();
server.close();
}
}
4.Socket客户端
* Socket(String host,int port)
* InputStream getInputStream()
* OutputStream getOutputStream()
* void close()
* shutdownOutput()
public class TCPClient {
public static void main(String[] args) throws IOException {
//1.创建客户端Socket对象,构造方法封装服务器的IP地址和端口号
Socket socket = new Socket("127.0.0.1",8888);
//2.使用Socket对象中的方法getOutputStream,获取网络字节输出流OutputStream对象
OutputStream os = socket.getOutputStream();
//3.使用网络字节输出流OutputStream对象中的方法write,给服务器发送数据
os.write("你好服务器".getBytes());
//4.使用Socket对象中的方法getInputStream,获取网络字节输入流InputStream对象
InputStream is = socket.getInputStream();
//5.使用网络字节输入流InputStream对象中的方法read,读取服务器回写的数据
byte[] bytes = new byte[1024];
int len = is.read(bytes);
System.out.println(new String(bytes,0,len));
//6.释放资源
socket.close();
}
}
#反射
1.概念
* 运行状态中,对于任意一个类,都能调用属性和方法,这种动态获取的信息以及动态调用对象的方法的功能称为反射
* 程序运行过程中,操作这些对象,可以解耦(通过配置文件帮我们创建对象)
2.获取Class文件三种方式
* getClass() 多用于配置文件
* String.class 多用于参数
* Class.forName("包名") 多用于对象获取字节码文件
3.常用类
* Class
* static Class<?> forName(String className)
* T newInstance()
* Constructor<T> getDeclaredConstructor(Class<?>...para)
* Constructor<?>[] getDeclaredConstructors()
* Field getDeclaredField(String name)
* Field[] getDeclareFields()
* Method getMethod(String name,Class<?>...parameterTypes)
* Method[] getMethods()
* String getName() 获取类名
* ClassLoader getClassLoader() 获取classLoader类加载器
* String getSimpleName() 获取简单类名
* Constructor
* T newInstance(Object...initargs)
* Constructor<?>[] getConstructors()
* clazz.getDeclaredConstructor().newInstance() 创建对象
* Field
* Object get(Object obj)
* void set(Object,Object value)
* void setAccessible(boolean flag) 解除私有
* Method
* Object invoke(Object obj,Object...args)
* ClassLoader
* InputStream getResourceAsStream(String name) 获取src下的资源(JAVA工程:Classes文件下的目录 Web工程:默认是读取WEB-INF/Classes文件下的目录)
4.类加载器
* 引导类加载器 jdk jre jvm 核心类库
* 扩展类加载器 jdk扩展类库
* 应用类加载器 负责加载我门写的类和第三方jar包
#Junit测试
1.导入Junit4.0包
* java类是公共的,没有无参的构造器
* 方法是公共的,没有返回值,无参数
* import org.junit.Test
* Assert.assertEquals()
* @before @after @Test
#注解
1.分类
* 编写文档
* 代码分析
* 编译检查
2.jdk常用注解
* @Override 重写
* @Deprecated 内容过时
* @SuppressWarnings 压制警告
3.自定义注解
public @interface 注解{
public abstract 数据类型 属性名()
public abstract 数据类型 属性名() default 1
}
@注解名(属性名=属性值,)
* 没有属性名可以直接使用
* 有属性的注解,必须键值赋值才行
* 有默认值可以不赋值
* 注解只有一个属性,属性名叫做value,那么赋值的时候可以省略属性名
* 属性的类型是数组类型,那么赋值多个值{},一个值可以省略{}
4.元注解
* java提供的注解,修饰自定义注解
* @Target() 声明使用位置
* @Retention() 自定义生命周期
#jdk1.8新特性
1.函数式编程思想
* lambda简化匿名内部类
* 可以提升性能,延迟加载(必须存在函数式接口)
new Thread(()->{
Systme.out.print();
}).start()
Arrays.sort(arr,(o1,o2)->{
return o1.getAge()-o2.getAge();
})
* 省略
* ()->{}
* 括号参数列表的数据类型可以省略不写
* 参数只有一个,类型和()可以不写
* 代码只有一行,{}可以省略,return和;也要省略
* 简化的接口必须仅有一个抽象方法
2.函数式接口
* 有且只有一个抽象方法接口,一般作为方法的参数和返回类型
@FunctionalInterface(检查接口是否是函数接口)
public interface MyFunctionalInterface{
abstract void method();
}
public interface MyFunctionalInterfaceImpl implements MyFunctionalInterface{
abstract void method("实现类从写");
}
public class Demo1{
public static void show(MyFunctionalInterface my){
my.method()
}
public static void main(String[] args){
show(new MyFunctionalInterfaceImpl())
show(new MyFunctionalInterface(){
public void method(){
System.out.print("匿名内部类重写的method方法")
}
})
show(()->System::print("xxxx"))
}
}
* Supplier<T>生产数据
* T get()接口指定什么泛型,使用get生产什么类型的数据
* Consumer<T>消费数据
* void accept(T t) 指定泛型数据,进行消费
* default Consumer<T> andThen(Consumer<? super T>after) 连接两个Consumer接口
* Function<T,R>数据类型转化接口
* R apply(T t) 根据T的参数获取R的结果
* Predicate对某种数据类型进行判断
* boolean test(T t)
* default Predicate<T> and(Predicate<? super T>other)
* && || !
3.Stream流
* 属于管道流,只能被消费使用一次,解决集合或数组弊端
* Collection或者Stream获取流
* default Stream<E> stream() Collection集合转换流
* static <T> Stream<T> of(T...value) Stream获取流
* 常用方法
* void forEach(Consumer<? super T> action) 遍历
* Stream<T> filter(Predicate<? super T> predicate) 过滤
* <R> Stream<R> map(Function<? super T,?extends R> mapper) 重新映射,流转换另外一个流
* Stream<T> skip(long n) 截取
* long count() 个数
* Stream<T> limit(long maxSize) 获取前几个元素
* static <T> Stream<T> concat(Stream<? extends T> a,Stream<? extends T> b) 两个流合成一个流
* public static <T> Collector<T,?,List<T>> toList() 转换为list集合
* public static <T> Collector<T,?,Set<T>> toSet() 转化为set集合
* object[] toArray() 转换数组
list.stream().filter(name->name.startwith("张")).filter(name->name.length()==3).foreach(name -> System.out::println)
stream.toArray() stream.collect(Collectors.toset())
* 第一个队伍名字只要3个名字的成员姓名,存放到新集合
4.方法引用
* 对lambda的优化,lambda方法已经存放在某个方法的实现中,可以使用方法引用
* 对象名引用成员方法
* str:tolowpper()
* 类名引用静态方法
* Math::random
* 类构造引用
* Person:new
* 数组构造引用
* int[]::new
* super调用父类
* super::父类方法
* this调用本类成员方法
* this::本类方法
#扩展
* 斗地主
public class DouDiZhu {
public static void main(String[] args) {
//1.创建一个Map集合,存储牌的索引和组装好的牌
HashMap<Integer,String> poker = new HashMap<>();
//2.存放索引的列表
ArrayList pokerIndex = new ArrayList<>();
//3.定义两个集合,存储花色和牌的序号
List colors = List.of(“♠”, “♥”, “♣”, “♦”);
List numbers = List.of(“2”, “A”, “K”, “Q”, “J”, “10”, “9”, “8”, “7”, “6”, “5”, “4”, “3”);
//4.把大王和小王存储到集合中,定义一个牌的索引
int index = 0;
poker.put(index,"大王");
pokerIndex.add(index);
index++;
poker.put(index,"小王");
pokerIndex.add(index);
index++;
//5.循环嵌套遍历两个集合,组装52张牌,存储到集合中
for (String number : numbers) {
for (String color : colors) {
poker.put(index,color+number);
pokerIndex.add(index);
index++;
}
}
Collections.shuffle(pokerIndex);
//6.定义4个集合,存储玩家牌的索引,和底牌的索引
ArrayList<Integer> player01 = new ArrayList<>();
ArrayList<Integer> player02 = new ArrayList<>();
ArrayList<Integer> player03 = new ArrayList<>();
ArrayList<Integer> diPai = new ArrayList<>();
//7.遍历存储牌索引的List集合,获取每一个牌的索引
for (int i = 0; i <pokerIndex.size() ; i++) {
Integer in = pokerIndex.get(i);
//8.先判断底牌
if(i>=51){
//9.给底牌发牌
diPai.add(in);
}else if(i%3==0){
player01.add(in);
}else if(i%3==1){
player02.add(in);
}else if(i%3==2){
player03.add(in);
}
}
Collections.sort(player01);
Collections.sort(player02);
Collections.sort(player03);
Collections.sort(diPai);
lookPoker("刘德华",poker,player01);
lookPoker("周润发",poker,player02);
lookPoker("周星驰",poker,player03);
lookPoker("底牌",poker,diPai);
}
//10.封装查看底牌
public static void lookPoker(String name,HashMap<Integer,String> poker,ArrayList<Integer> list){
//11.遍历玩家或者底牌集合,获取牌的索引
for (Integer key : list) {
//12.使用牌的索引,去Map集合中,找到对应的牌
String value = poker.get(key);
//13.打印完每一个玩家的牌
System.out.print(name+""+value+" ");
}
//14.换行,更好显示
System.out.println();
}
}
上一篇： JavaSE基础
下一篇： 优化程序之——宏与内联函数