Java语法
2020-07-31 14:28:29 3 举报AI智能生成
Java语法
作者其他创作
大纲/内容
进阶语法
常用API
Object
toString
不覆写，返回地址
System
static long currentTimeMillis()`：返回以毫秒为单位的当前时间。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。 <br>
equals
与等号的差别
ide有覆写好的equals方法，可以判断类和其内容是否相同
Objects
7出来的工具类
null-save（空指针安全的）或null-tolerant（容忍空指针的）
equals
DateFormat和simpleDateFormat
1.String format(Date date)将Date对象格式化为字符串。<br>2.Date parse(String source)将字符串解析为Date对象。
Date
long getTime( )把日期对象转换成对应的时间毫秒值。
Calender
static Calendar getInstance()返回日历类的实例
int get(int field)： int year = cal.get(Calendar.YEAR);
void set(int field, int value)
abstract void add(int field, int amount)
Date getTime()
StringBuilder
StringBuilder append(...)
String toString()
包装类
自动装箱
Integer i = 1
自动拆箱
int i = new Integer(10)
Collection集合
<br><br><br>特点<br>
<br><br><br>数组的长度是固定的。集合的长度是可变的。<br>
常用方法
boolean add(E e)
void clear()
boolean remove(E e)
boolean contains(E e)
boolean isEmpty()
int size()
Object[] toArray()把集合中的元素，存储到数组中。
<br><br>遍历<br>
<br><br><br>Itrator 迭代器<br>
<br><br><br>迭代取出所有元素<br>
hasNext( )&&next( )
增强for
不要在遍历的过程中对集合元素进行增删操作，否则用for循环
List
<br><br>Collection的子接口<br>
特点
①有索引、②可以保证存取顺序、③可以存储重复元素
特有方法
void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
E get(int index) :返回集合中指定位置的元素。
E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
ArrayList
特点
元素增删慢，查找快
数组结构
使用
使用最多的功能为查询数据、遍历数据
LinkedList
特点
链表结构。
方便元素添加、删除的集合。
Set
<br><br><br>Collection的子接口<br>
特点
①不允许存储重复的元素。<br>
因为add()方法调用了hashCode()和equals()方法
②没有索引，没有带索引的方法，也不能使用普通的for循环遍历。
HashSet
特点
③是一个无序的集合，存储元素和取出元素的顺序有可能不一致。<br>
④（查询的速度非常的快）底层是一个哈希表的结构
<br><br>原理<br>
<br>1.8之前：<br>哈希表 = 数组 + 链表；<br><br>1.8之后：<br>哈希表 = 数组 + 链表/红黑树；<br>
<br><br>把元素按哈希值分组，储存到数组中，再把哈希值相同的用链表链接，如果超过8个，转换为红黑树<br>
哈希值：<br>
是一个十进制的整数，由系统随机给出（就是对象的一个逻辑地址，不是数据实际存储的物理地址）
Object类的：<br>public native int hashCode()返回对象的哈希值。<br>native：代表该方法调用的是本地操作系统的方法。<br>
LinkedHashSet
哈希表（数组+链表/红黑树）+链表
多了一条（记录元素的存储顺序），保证元素有序。
jdk9的一个新特性
List,Set,Map三个接口中添加了，静态的方法of,可以给集合中一次性添加多个元素
static <E> List<E> of (E...elements)
注意
集合中存储的元素的个数已经确定了，不在改变时使用。
of方法只能List，Set，Map用，实现类不能使用
Set和Map在调用of方法时，不能有重复的元素，否则会抛出异常
可变参数
可变参数底层是一个数组。
注意
一个方法的参数列表，只能有一个可变参数
如果方法的参数有几个，那么可变参数必须写在参数列表的末尾。
Collections
<br><br>java.utils.Collections 是集合工具类，用来对集合进行操作。<br>
常用方法
static <T> boolean addAll(Collection<T> c, T... elements) :往集合中添加一些元素。
static void shuffle(List<?> list) 打乱顺序 :打乱集合顺序。
排序
排序自定义类时，需要实现Comparable<T>接口
static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。简单些，推荐
static <T> void sort(List<T> list，Comparator<? super T> ) :将集合中元素按照指定规则排序，Comparator是一个函数式接口<br>
Map
<br><br>特点<br>
<br><br>Map集合中的元素，key和value的类型可以相同，也可不同<br>
Map集合中的元素，key是不予许重复的，value是可以重复的
Map集合中的元素，key和value是一 一 对应的。
常用方法
V put(K key, V value) : 把指定的键与指定的值添加到Map集合中。
V remove(Object key) : 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。<br>
V get(Object key) 根据指定的键，在Map集合中获取对应的值。
Set<K> keySet() : 获取Map集合中所有的键，存储到Set集合中。
Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。
遍历
利用Set<K> keySet()，获取Set集合，遍历Set，在get(key)获得Value
通过Set<Map.Entry<K,V>> entrySet()来遍历
用接口Map.Entry<K,V>里的方法getKey(),getValue()
HashMap
特点
是一个线程不安全的集合，是多线程集合，速度快，可以存<null，null>
底层是一个哈希表，查询速度特别快。<br>
hashMap是一个无序集合，存储元素和取出元素的顺序可能不一致
自定义类作为key时，需要覆写equals（）和hashCode（），保证key不重复
LinkedHashMap
LinkedHashMap集合底层是一个哈希表+链表（保证迭代顺序）
这个集合是一个有序集合，存储元素和取出元素的顺序都是一致的。
HashTable
底层也是一个哈希表，是一个线程安全的结合，是单线程，速度慢<br>不能存null
泛型
<br><br><br>好处<br>
<br><br><br>避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型。<br>
把运行器异常（代码运行之后会抛出的异常），提升到了编译器（写代码的时候会报错）
使用
定义、使用含有泛型的类
class Person<T><br>Person<String> per = new Person<>();<br>
定义、使用含有泛型的接口，抽象方法用法一样
interface Person<E> {<br> void doing(E e);}
第一种：在实现接口时，就将泛型指定了
第二种：在创建对象时，才将泛型指定
class StudentImpl<E> implements Person<E>
定义、使用含有泛型的方法
异常
Throwable
Error
必须修改源代码
Exception
Checked异常
可以被处理的异常，所以Java程序必须显示处理Checked异常（就是ide中常见的红线）。如果没有处理，进行编译java文件会出现编译出错。无法编译，没有.class文件。
runtimeException
运行期间异常，java程序运行过程中出现的问题
异常处理的处理方式
Throws
try...catch..finally...
finally可以写return
版本更新
JDK7前处理<br>try...catch...finally 代码块，处理异常部分
JDK7的处理<br>还可以使用JDK7优化后的 try-with-resource 语句，该语句确保了每个资源在语句结束时关闭。所谓的资源（resource）是指在程序完成后，必须关闭的对象。
JDK9的改进<br>JDK9中 try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，<br>无需手动close
Throw
自定义异常类
父类方法的抛出异常是什么，子类就抛出什么异常，或者不抛出异常。父类没有异常，子就不能写throws
多线程
Thread
构造方法
public Thread(Runnable target,String name) :等，以这个参数列表做无序排列
常用方法
String getName() :获取当前线程名称。
static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
static Thread currentThread() :返回对当前正在执行的线程对象的引用。
Runnable
构造方法
public Thread(Runnable target)
public Thread(Runnable target,String name)
Thread和Runnable区别
Runable接口的话，可以实现资源共享。多个Thread线程不能。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。创建线程任务和启动线程独立。
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
同步
同步代码块
synchronized(同步锁){<br> 需要同步操作的代码<br>}
同步方法
public synchronized void method(){<br> 可能会产生线程安全问题的代码<br>}
锁机制
public void lock() :加同步锁。<br>public void unlock() :释放同步锁。
同步锁
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.<br> 1. 锁对象 可以是任意类型。<br> 2. 多个线程对象 要使用同一把锁。<br>在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着<br>
线程间的通信
wait和notify
线程池
Executors类
常用方法
static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)获取到了一个线程池ExecutorService 对象
public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象，就直接run了，并执行<br>Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用。
File类
相对路径&&绝对路径
Idea：相对路径是相对于当前项目
构造方法
有三种
常用方法
获取
String getAbsolutePath() ：返回此File的绝对路径名字符串。
String getPath() ：将此File转换为路径名字符串。构造方法写的啥，就是啥。
String getName() ：返回由此File表示的文件或目录的名称。
long length() ：返回由此File表示的文件的长度。文件夹没有大小，文件才有。
判断
boolean exists() ：此File表示的文件或目录是否实际存在。
boolean isDirectory() ：此File表示的是否为目录。
boolean isFile() ：此File表示的是否为文件。
删除
boolean delete() ：删除由此File表示的文件或目录。
创建
boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。
遍历
String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录
过滤器FileFilter
函数式接口
boolean accept(File pathname) ：测试pathname（file对象）是否应该包含在当前File目录中，符合则返回true。并且把该pathname保存到file数组中去
IO流
字节流
<br><br>输入：从硬盘读取数据，向内存中输入数据读取<br>输出：从内存中输出数据，写入数据进硬盘中保存<br>
OutputStream
常用方法
void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
abstract void write(int b) ：将指定的字节输出流。每次可以写出一个字节数据
void write(byte[] b) ：将 b.length字节从指定的字节数组写入此输出流。
void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 offff开始输出到此输出流。
子类
FileOutputStream
public FileOutputStream(File file)，可以加参数boolean，代表是否追加写
等
InputStream
常用方法
public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
abstract int read() ： 从输入流读取数据的下一个字节。读一个，指针向后移一位，直到末尾，返回-1，返回读取字节的值
int read(byte[] b) ： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。每次都读b那么长的字节，并存入b中，直到读完。b作缓冲作用，存储得到的字节，int放回每次读到字节的个数
子类
FileInputStream
等
字符流
Reader
子类
Writer
注意事项
使用Filewriter中的方法write,把数据写入到内存缓冲区中(字符转换为字节的过程)
使用FileWriter中的方法flush,把内存缓冲区中的数据,刷新到文件中，不关闭输出流。
close( )释放资源(会先把内存缓冲区中的数据刷新到文件中)，关闭输出流。
close&&flush
flush：刷新缓冲区，流对象可以继续使用。
close :先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。
Properties类
<br><br><br>继承于 Hashtable ，它使用键值结构存储数据，每个键及其对应值都是一个字符串。他是唯一 一个和IO流结合的集合。利用Properties可以向文件输出键值对，从文件输入键值对<br>
常用方法
Object setProperty(String key, String value) ： 保存一对属性。
String getProperty(String key) ：使用此属性列表中指定的键搜索属性值。
Set<String> stringPropertyNames() ：所有键的名称的集合。
void load(InputStream inStream) ： 从字节输入流中读取键值对
void store(Write write , String comments): 从字符输出流中，写入键值对
缓冲流
字节缓冲流
BufferedInputStream(InputStream in) ：创建一个 新的缓冲输入流。
BufferedOutputStream(OutputStream out) ： 创建一个新的缓冲输出流。
字符缓冲流
BufferedReader(Reader in) ：创建一个 新的缓冲输入流。
BufferedWriter(Writer out) ： 创建一个新的缓冲输出流。
特有方法
BufferedReader： public String readLine() : 读一行文字。
BufferedWriter： public void newLine() : 写一行行分隔符,由系统属性定义符号。
转换流
字符编码
编码：自然语言的字符->二进制：根据字符集，知道对应的数字，在把数字化成二进制
解码：二进制->自然语言的字符
字符集
ASCII字符集
ISO-8859-1字符集
GBxxx字符集
GB2312
GBK
双字节编码方案
GB18030
Unicode字符集
UTF-8
一至四个字节为每个字符编码
常用字（含中文），使用三个字节编码
UTF-16
UTF-32
InputStreamReader类
InputStreamReader(InputStream in, String charsetName) : 创建一个指定字符集的字符流。<br>
是Reader的子接口
OutputStreamReader类
OutputStreamReader(OutputStream out, String charsetName) : 创建一个指定字符集的字符流。<br>
打印流
可以改变输出目的地，例如文件，而不是像Console中输入，System.setOut(ps)
System有三个字段：out，in，
static PrintStream out “标准”输出流。
static InputStream in “标准”输入流。
static PrintStream err “标准”错误输出流。
对象的序列化和反序列化
ObjectOutputStream类
序列化流：将Java对象的原始数据类型写出到文件,实现对象的持久存储。
使用集合，可以向文件序列化对象集合
final void writeObject(Object obj)
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Advanced\\src\\对象的序列化流\\2.txt"));
ObjectInputStream类
反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象
final Object readObject()
网络编程
应用层
Https，DNS等
传输层
TCP
直译是一种传输控制协议，是面向连接的通信协议，三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。
使用步骤
1.创建一个客户端对象Socket，构造方法绑定服务器的IP地址和端口号
2.使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
3.使用网络字节输出流OutputStream对象中的方法write(),给服务端发送数据
4,使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
5.使用网络字节输入流InputStream对象中的read（），读取服务器回写的数据
6.释放资源
模拟B/S，访问本地网页
UDP
容易丢失数据，但是传输快，例如视频电话就是UDP
函数式接口
Lambda表达式
简化代码，其实就是匿名内部类的另一种形式，不过很简洁，
使用Lambda的延迟执行：来解决性能浪费，例如：日志案例
自定义时用@FunctionalInterface声明，只能有一个抽象方法
常用的函数接口
Supplier<T>
T get() 用来获取一个泛型参数指定类型的对象数据。
Consumer<T>
使用accept来消费，或者通过andThen组合消费，即一次消费多个
con1.andThen(con2).accept(str)
Predicate<T>接口
对某种类型的数据进行判断，从而得到一个boolean值结果，可以判断与，或，非
pre1.or(pre2).test("Hello")
pre1.and(pre2).test("HelloWorld")
pre.negate().test("hello")
Function接口
R apply(T t) ，根据类型T的参数获取类型R的结果。也就是根据前面那个T,得到后面那个R
fun1.andThen(fun2).apply(age)
可以做参数，返回值
可简化至：str-> str.contains("H")
Stream流
<br><br><br><br>8新加入的最常用的流接口。（这并不是一个函数式接口。）<br>
获取
Collection集合所有子类都可通过stream(),转化为Stream流，Map通过keySet(),entrySet()
静态方法Stream.of(T...)
常用方法
延迟方法
返回值类型仍然是 Stream 接口自身
Stream<T> filter(Predicate<? super T> predicate);用来过滤流，形成一个新的流
<R> Stream<R> map(Function<? super T, ? extends R> mapper);//使用map将流中的元素映射到另一个流中,下面是将String转换为Integer类型
Stream<T> limit(long maxSize);只要前几个
Stream<T> skip(long n);不要前几个
<T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)：concat方法把两个流连接起来
终结方法，不返回Stream
Foreach
void forEach(Consumer<? super T> action)
count
long count();
注意事项
Stream流属于管道流，只能被使用一次，流只要被使用了，就会关闭，否则会抛出异常
方法引用
<br><br><br>使Lambda内的覆写部分更加简化，我愿称之为减霸JB，但其实看代码不容易看，还不如不简写<br>
双冒号 :: 为引用运算符，而它所在的表达式被称为方法引用
通过类名引用静态成员方法类已经存在，静态成员方法也已经存在，就可以通过类名直接引用静态成员方法
使用super引用类的成员方法，super是已经存在的父类的成员方法，所以可以直接使用super引用父类的成员方法
通过this来调用本类方法
构造方法new Person(String name)已知，创建对象已知 new，就可以使用Person引用new创建对象
通过对象名引用成员方法使用前提是对象名是已经存在的，成员方法也是已经存在的，就可以使用对象名来引用成员方法
计算机基础知识
计算及储存单元
位(bit):代表二进制数0&1
字节(byte):1byte = 8bit
KB:1KB = 1024byte
MB: 1MB = 1024KB
生活中常见的网速：1M即1Mb/s(1Mbps)等于125KB/S,<br>运行商说的100M，其实速度只有12.5MB/S<br>
1GB : 1GB =1024MB
TB : 1TB = 1024GB
PB: 1PB =1024TB
EB: 1EB =1024PB
ZB: 1ZB=1024EB
命令行cmd
启动
切换盘符：盘符名称：F
进入文件夹：cd 文件夹
进入多级：cd 文件夹\文件夹
返回上一级：cd..
根路径：cd\
当前文件目录：dir
清屏：cls
退出：exit
idea
快捷键
基础语法
入门知识
01_JVM，JRE，JDK三者关系
02_运算符
算术运算符
+, -, *, /, %, ++, --
赋值运算符
=, +=, -=, *=, /=, %=
逻辑运算符
& , &&, |, ||,
一元运算符
正+，负-，否！
三元运算符
int i=true？ 1：2<br>i结果为1<br>
比较运算符
==, <, >, <=, >= , !=
03_数据类型
基本数据类型
byte
int
整数默认int
long
short
float
double
小数默认double
char
引用数据类型
类
接口
数组
数据类型之间的转换
自动转换
1.需要转换后的类型范围要大，小->大<br>2.需要转换的类型兼容<br>eg：short i =100；int j =0; j=i
byte/short/char 在运算时，首先被提升成为int类型，然后在计算。
强制转换
大->小
boolean不能转换
有时会造成数据溢出，精度缺失
04_程序结构
顺序，循环，选择
05_java中的内存有哪些<br>
<ol><li>栈：方法的运行一定在这里</li><li>堆，new出来的</li><li>方法区：储存.class文件，和方法的信息</li><li>本地方法栈</li><li>寄存器</li></ol><br>
06_数组
定义方式
数组长度不可变
数组是被new出来的
07_方法
定义
方法的重载
方法名一样参数个数，参数的数据类型不同，类型顺序不同
面向对象
封装
类
成员方法
成员变量
对象
类的具体
成员变量&局部变量
成员变量属于类，局部变量属于方法
构造方法
匿名对象
this
调用本类方法，变量
构造方法调用
需要有个出口，即不调用构造方法
代表调用当前方法的对象
作为返回值，返回本类的对象
做参数
Static关键字
被声明为Static的属于类，被对象所共享
静态方法不能调用非静态的，除非通过传参，可以调用非静态，这涉及到内存开辟的先后顺序
不能用this调用静态声明的成员
Static声明的成员，内存被先开辟，所以不能调用非静态
非静态需要使用对象调用
静态代码块
优先执行，只执行一次，用于给静态变量一次性赋值
常用类库
Arrays
ArrayList
String
Math
Random
Scanner
继承
特点
单继承，多级继承，多个子类<br>
子类可以覆写，可以新增方法
覆写&重载
覆写不能改形参，方法名，返回值
覆写权限必须比原来大或等
super
调用父类的成员
成员变量，方法，构造方法
抽象方法<br>
特点
有抽象方法必是抽象类
抽象类可以有构造方法
抽象类可以没抽象方法
子类必须全部覆写抽象方法，除非子类是抽象类
接口
特点
所有方法都是抽象方法
所有变量为final static，全局常量
接口能够继承多个接口
类能多实现，单继承
jdk8出来了静态方法，默认方法，jdk9出来了私有方法
静态方法
默认方法
用于接口升级
私有方法
解决多个默认方法之间重复代码
注意事项
没有构造方法，静态代码块
只能有一个父类，但是允许继承多个接口
抽象类可以不覆写完接口所有的抽象方法
父类和接口当中的默认方法同名，优先调用父类的
实现了多个接口，重名了，只用覆写一个
默认方法可以不被覆写，但是实现多个接口时，遇到重复的，需要覆写
多态
类型
向下转型
父 -> 子
1.先要向上转型（有父才有子）：Fu f = new Zi( );<br>2.在向下转型： Zi z = (Zi)f;
向上转型
子 -> 父
Fu f = new Zi( )
特点
访问成员变量
编译看左，运行还是看左
成员
编译看左，运行看右
final关键字
修饰类，那该类不能被继承，方法不能被覆写
修饰方法，不能被覆写
修饰变量，为常量
<ol><li>修饰基本数据类型，其内容不能被修改</li><li>修饰引用数据类型，其地址不能被修改</li></ol>
必须要被手动赋值，因为不手动，就被赋值为初始值0等
权限修饰符
权限从上到下
public
protected
default
private
内部类
成员内部类
1.内用外，随意访问: <br>
2.外用内，露要内部类对象。
外部类名称.内部类名称 对象名= new 外部类名称().new内部类名称();
如果要成员内部类要访问，所在方法的局部变量，那么需要用【final】修饰局部变量
因为方法调用完，局部变量，没了，但是变为常量，在常量池中
匿名内部类
0 条评论
下一页
