一、集合框架
1、接口
1-1：Collection：不唯一、无序
1>List：不唯一、有序
2>Set： 唯一、无序
1-2：Map： 键-值对 key-value(k-v)
1-3：Iterator：对集合进行迭代的迭代器、实现集合的遍历
2、实现类及方法
2-1：Collection方法：
add(Object o) 在列表的末尾添加元素，起始索引位置从0开始
size() 返回列表中的元素个数
contains(Object o) 判断列表中是否存在指定元素
remove(Object o) 从列表中删除元素
clear()、isEmpty()、iterator()、toArray ()、
2-2：List接口：
1>ArrayList类的方法
get(int index) 返回指定索引位置处的元素，取出的元素是Object类型，使用前需要进行强制类型转换
2>LinkedList类的方法
addFirst() 将给定元素插入当前集合的首部
addLast() 将给定元素插入当前集合的尾部
getFirst() 获得当前集合的第一个元素
getLast() 获得当前集合的最后一个元素
removeFirst() 删除当前集合的第一个元素
removeLast() 删除当前集合的最后一个元素
★ArrayList：（查）因为可以使用索引来直接获取元素，所以优点是遍历元素和随机访问元素的效率比较高
LinkedList：（增、删、改、）采用链表存储方式，优点在于插入、删除、修改元素时效率比较高，但是查找效率低
2-3：Set接口：里面存放的是对象的引用、使用对象equals()方法比较是否为同一对象
1>HashSet类的方法
isEmpty()：如果此Set不包含任何元素，则返回true
2>遍历Set集合
方法一：增强型for
方法二：使用迭代器 Iterator
A：获取Iterator：Collection接口的iterator()方法 Iterator iter=news.iterator();
B：使用hasNext()来判断是否存在另一个可访问的元素 while(iter.hasNext())
C：使用next()来返回要访问的下一个元素 (Type)iter.next()
2-4：Map接口：处理键值映射数据的存储，可以根据键实现对值的操作
1>常用方法：
Object put(Object key,Object val)：以“键-值”对的方式进行存储
Object get(Object key)：根据键返回相关联的值，如果不存在指定的键，则返回null
Object remove(Object key)：删除由指定的键映射的“键-值”对
int size()：返回元素的个数
Set keySet()：返回键的集合
Collection valuse()：返回值的集合
boolean containsKey(Obkject key)：如果存在由指定的键映射的“键-值”对，返回true
Set entrySet()：获得键值对
2>HashMap：动态存储数据，优点是查询指定元素效率高
3>获取Map键和值的方式：
A、keySet()——Set→迭代这个Set（Iterator）→get（key）
Set keys=countries.keySet();
Iterator iter=keys.iterator();
while(iter.hasNext()){
String key=(String) iter.next();
String value=(String)countries.get(key);
System.out.println(key+"--"+value);
}
B、entrySet()——Set(Map.Entry)→增强型for（或者Iterator）→getKe()、getValue()
Set set=countries.entrySet();
for(Object obj:set){
String key=(String)((Map.Entry)obj).getKey();
String value=(String)((Map.Entry)obj).getValue();
System.out.println(key+"--"+value);
}
3、Collections类是对操作集合
1>对集合元素排序（sort：升序、reverse：降序）
通过sort()方法进行排序（先实现Comparable接口→重写compareTo()方法）
public int compareTo(Object o) {
Student student = (Student) o;
if(this.number==student.number){
return 0;
}else if(this.number>student.number){
return 1;
}else{
return -1;
}
}
2>对集合元素查找：binarySearch()、max()查找最大值、min()查找最小值
3>对集合元素替换：fill() 把所有的元素都替换为相同的元素
4>
二、泛型
语法：类1或者接口<类型实参> 对象=new 类2<类型实参>();
好处：保证类型转换的安全性和稳定性
三、实用类
1、枚举：由一组固定的常量组成的类型
访问修饰符 enum 枚举类型变量名{ 枚举常量列表 }
2、包装类：把基本类型数据转换为对象
2-1：构造方法
1>所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例
2>除Character类外，其他包装类可将一个字符串作为参数构造它们的实例
★Number类型的构造时，参数必须能转换为相应的数字，不然NumberFormatException
Boolean类型构造时，除了true(大小写)以外全都是false
2-2：常用方法
1>**Value()：包装类转换成基本数据类型
Number包装类型转换为基本数据类型
Boolean 包装类型转换为基本数据类型
Character包装类型转换为基本数据类型（charValue()）
2>toString()：返回字符串
3>valueOf()：返回包装类型
★所有包装类valueOf(type type)
包装类valueOf(String s) →除Character之外
4>parse**()：把字符串转换为相应的基本类型数据（Character除外）
2-3：包装类型→基本数据类型 （拆箱）
基本数据类型→包装类型（装箱））
3、Math类
生成随即方式有两种：
1>java.lang.Math
int random=(int)(Math.random()*10); 生成一个0-9之间的随机数
2>java.util.Random
Random rand=new Random(); //创建一个Random对象
int num=rand.nextInt(种子); //返回下一个随机整数
4、操作字符串的实用类
4-1：String字符串类的方法
1>length()：返回字符串的长度
2>equals()：比较两个字符串的值是否相同
3>equalsIgnoreCase()：比较两个字符串时，忽略大小写
4>toLowerCase()：转换为小写
5>toUpperCase()：转换为大写
6>concat()：连接字符串
7>int indexOf(int ch)：搜索第一个出现的字符ch（或者字符串 value），找不到返回-1
int indexOf（(String value)
int lastIndexOf(int ch)：搜索最后一个出现的字符ch（或者字符串 value），找不到返回-1
int lastIndexOf(String value)
String substring(int index)：提取从位置索引开始的字符串部分，，截取到字符串的末尾，包含index
String substring(int beginindex，int endindex)：提取beginindex（包含）和endindex（不包含）之间的字符串部分
String trim()：返回一个前后不含任何空格的调用字符串的副本
8>split：对字符串进行拆分 ——String[]
4-2：StringBuffer类：频繁修改字符串，效率比String高
初始化：StringBuffer s=new StringBuffer("content");
1>toString()：转换为String类型的对象
2>append(参数)：将参数连接到字符串并返回
3>insert(位置，参数)：将参数插入到字符串的指定位置后并返回
5、日期时间类
5-1：java.util.Date; import java.text.SimpleDateFormat;
1>Date date=new Date();使用系统当前时间创建日期对象
2>SimpleDateFormat formater=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");格式化时间
formater.format(date) 输入当前时间
5-2：import java.util.Calendar;
Calendar calendar=Calendar.getInstance();
set()：设置时间 get()：获取时间
1>YEAR：年
2>MONTH：月（+1）
3>DAY_OF_MONTH：日
4>DAY_OF_WEEK：星期（-1）
四、输入和输出（I/O） java API：java.io;
1、File类：文件的属性或操作
1-1：常用方法
创建文件
exists()：判断呢文件或目录是否存在
createNewFile()：创建空文件，不能创建文件夹
删除文件
exists()
delete()：删除此对象指定的文件
获取文件相关信息
isFile()：判断是否是文件
isDirectory()：判断是否是目录
getName()：返回此对象表示的文件或目录的名称
getPath()：返回此对象表示的文件的相对路径
getAbsolutePath()：返回此对象表示的文件的绝对路径
length()：返回文件的长度，单位为字节，如果文件不存在，则返回0L
2、流：指一连串流动的字符，以先进先出的方式和发送和接收数据的通道
2-1：流的划分（基类也就是父类）
1>流向：
输入流：InputStream、Reader
输出流：OutputStream、Writer
2>数据单位：
字节流：InputStream、OutputStream
字符流：Reader、Writerr
2-2：流的使用
1>字节流：
A：输入流：public abstract class InputStream
方法：int read()：从输入流中读取下一个字节，返回0-255之间的int值.返回值代表着都出来的字节对应的整型数字
int read(byte[] b)：从输入流中读取一堆字节，把这些字节存储在字节数组b中。返回值代表着真实的读到的字节的个数（b的长度）
int read(byte[] b,int off,int len)：从输入流中读取一堆字节，把这些字节存储在字节数组b中。off对应的是b开始存储字节的标识或下标（将读取的第一个字节存储在元素 b[off] 中）。len对应的是读到的字节的个数或长度
available()：可以从输入流中读取的字节数目
close()：关闭输入流
★子类FileInputStream常用的构造方法
FileInputStream (File file)
FileInputStream(String name)
B：输出流：public abstract class OutputStream
方法：void write(int c)：写入一个字节数据
void write(byte[] buf)：写入数据buf的所有字节
void write(byte[] b,int off,int len)：将字节数组中off位置开始，长度为len的字节数据输出到输出流中
void close()：关闭输出流
void flush()：强制把缓冲区的数据写到输出流中
void write(byte[] buf)
★子类FileOutputStream常用的构造方法
FileOutputStream (File file)
FileOutputStream(String name)
FileOutputStream(String name,boolean append)
2>字符流
A：输入流：public abstract class Reader
方法：int read()：从输入流中读取下一个字符，返回0-65535之间的int值.返回值代表着都出来的字符对应的整型数字
int read(byte[] b)：从输入流中读取一堆字符，把这些字符存储在字节数组b中。返回值代表着真实的读到的字符的个数（b的长度）
int read(byte[] b,int off,int len)：从输入流中读取一堆字符，把这些字符存储在字符数组b中。off对应的是b开始存储字符的标识或下标（将读取的第一个字符存储在元素 b[off] 中）。len对应的是读到的字符的个数或长度
available()：可以从输入流中读取的字符数目
close()：关闭输入流
★其子类InputStreamReader的构造方法
InputStreamReader（InputStream stream）
InputStreamReader（InputStream stream, String charsetName）
★InputStreamReader的子类FileReader的构造方法
FileReader(File file)
FileReader(String pathName)
FileReader只能按照本地平台的字符编码来读，不能通过用户特定的字符编码来读
本地平台的字符编码获得：System.getProperty("file.encoding");
B：输出流：public abstract class Writer
方法：write(String str)：写入一个字符串数据
write(char[] c)：
write(String str,int off,int len)：将str字符串数组中off位置开始，长度为len的字符串数据输出到输出流中
void close()：关闭输出流
void flush()：强制把缓冲区的数据写到输出流中void write(byte[] buf)
★其子类OutputStreamWriter的构造方法
OutputStreamWriter(OutputStreamWriter stream)
OutputStreamWriter(OutputStreamWriter stream,String charsetName)
★OutputStreamWriter的子类FileWriter的构造方法
FileWriter(File file)
FileWriter(String pathName)
FileWriter只能按照本地平台的字符编码来写，不能通过用户特定的字符编码来写
2-3：读写文本文件
1>用FileInputStream读文本文件
A：引入相关类
B：创建输入流对象（FileInputStream对象）
FileInputStream fis = new FileInputStream("text.txt",true);
C：读取文本文件（read()）
fis.available()：可读取的字节数
fis.read()：读取文件的数据
D：关闭流
★BufferedReader：带有缓冲区的字符输入流
构造方法：
BufferedReader(Reader reader)
readLine()-->String
2>使用FileWriter往文本文件中写数据步骤：
A：引入相关类
B：创建输出流对象（FileWriter对象）
Writer fw = new FileFileWriter("text.txt");
C：写入文本文件（write()）
write()
D：关闭流
★BufferedWriter：带有缓冲区的字符输出流
构造方法：
BufferedWriter(Writer)
write()：写入
flush()：清空缓冲区
newLine()：换行
replace(oldChar, newChar)：把oldChar替换newchar
2-4：二进制文件读取和写入（图片、音频）
DataInputStream：读
DataOutputStream：写
五、序列化和反序列化
1、定义
序列化是将对象的状态写入到特定的流中的过程
反序列化则是从特定的流中获取数据重新构建对象的过程
2、步骤
2-1：序列化
1>实现Serializable接口
2>创建对象输出流 ObjectOutputStream
3>调用writeObject()方法将对象写入文件
4>关闭对象输出流
2-2：反序列化：
1>实现Serializable接口
2>创建对象输入流 ObjectInputStream
3>调用readObject()方法读取对象
4>关闭对象输入流
★可以为对象某些属性添加transient，这些属性将不再被序列化
六、多线程
1、线程的步骤
1-1：创建线程的两种方式：
1>extends Thread
2>implements Runnable→
1-2：重写run()方法
1-3：启动线程：start()
2、线程状态：新生、可运行、阻塞、死亡
3、线程调度
3-1：优先级：1-10表示，1最低，10 最高，默认为5
3-2：实现调度的方法：
1>join()：等待该线程终止
2>sleep(long millis)：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
3>yieId()：暂停当前正在执行的线程对象，并执行其它线程
4、线程同步：通过synchronized关键字实现
4-1：同步方法
4-2：同步代码块
七、网络编程
1、IP
ipconfig：查看本机IP地址
ping 目标IP地址：测试网络是否通畅
2、网络服务器
客户机→服务器（Client/Server）(C/S)
浏览器→服务器（Browser/Server）(B/S)
3、Socket：套接字 位于java.net包
3-1：流式套接字：基于TCP协议的Socket
1>服务器端
A、创建一个服务器Socket
ServerSocket serverSocket=new ServerSocke(8800);
B、使用accept()等待客户的通信
Socket socket=serverSocket.accept();
C、获得输入流，获得相应的用户请求
InputStream is=socket.getInputStream();
BufferedReader br=new BufferedReader(new InputStreamReader(is));
。。。。
D、通过输出流，给客户端一个响应
OutputStream os=socket.getOutputStream();
。。。。
E、释放相应资源
2>客户端：
A、创建一个客户端Socket
Socket socket=new Socket("localhost",8800);
B、通过输出流发送请求
OutputStream os=socket.getOutputStream();
。。。。。
scoket.shutdownOutput();
C、通过输入流接收服务器给我的响应
InputStream is=socket.getInputStream();
。。。。。
D、释放资源
★多线程完成多客户端请求：InetAddress
3-2：数据包式套接字：基于UDP协议的Socket网络编程
1>服务器
A、创建DatagramPacket对象，用来准备接收数据包
byte[] infos = new byte[1024];
DatagramPacket dp = new DatagramPacket(infos, infos.length);
B、创建DatagramSocket对象，接受数据
DatagramSocket socket= new DatagramSocket(8800);
socket.receive(dp);
C、利用DatagramPacket对象处理数据
2>客户端
A、获取本地主机的InetAddress对象
InetAddress ia=InetAddress.getByName("localhost");
B、创建DatagramPacket对象，封装要发送的信息
DatagramPacket dp=new DatagramPacket(infos, infos.length, ia, 8800);
C、创建DatagramSocket对象，向服务器发送数据
DatagramSocket socket=new DatagramSocket();
socket.send(dp);
八、XML：可扩展标记语言
1、、XML文档基本结构
1-1：XML声明(一般位于文档的第一句话)
<?xml version="1.0" encoding="utf-8"?>
1-2：每个XML文档都有且只有一个根元素
1-3：每个元素如果成对出现，要一起敲出来
1-4：各元素之间如果有层级关系，注意缩进
1-5：xml注释 <!--注释内容-->
2、元素
<元素名 属性名="属性值">元素内容</元素名>
3、使用DOM解析读取XML数据
3-1：创建解析器工厂对象，即DocumentBuilderFactory对象
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
3-2：由解析器工厂对象创建解析器对象，即DocumentBuilder对象
DocumentBuilder builder = factory.newDocumentBuilder();
3-3：由解析器对象对指定的XML文件进行解析，构建相应的DOM树，创建Document对象
Document document = builder.parse("路径");
3-4：以Document对象为起点对DOM树的节点进行增加、删除、修改、查询等操作
扫一扫
493
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
