java 高级特性
2018-06-29 10:38:50 0 举报AI智能生成
java 高级，java 高级，java 高级
作者其他创作
大纲/内容
1.集合框架
Map
HashTable 和HashMap区别
HashTable 线程安全 HashMap线程不安全
HashMap key 可以存null 值 HashTable 不可以存null 运行时异常 编译能通过
HashMap put(key,value) remove(key) 改put(key,value) get(key)
HashMap集合的遍历 通过key 去找value key 是一个Set 集合,所以key 是唯一的
增加for循环遍历
for (String key : map.keySet()) {
String value = map.get(key);
System.out.println(value);
}
迭代器 遍历map Iterator iter = map.keySet().iterator();
while(iter.hasNext()){
String key = (String)iter.next();
System.out.println(key);
String value =(String)map.get(key);
System.out.println(value);
}
Collection
List 有序,不唯一
ArrayList 基于数组 随机读取数据快 add(obj) remove(index) add(int,obj); get(index)
LindkedList 基于链表的集合,删除和插入效率比较高 addFirst()addLast() removeFirst() removeLast();
Vector 和ArrayList 区别 Vector 线程安全 synchronized ArrayList线程不安全
set 无序,唯一 equals()
HashSet 采用对象的equals()方法比较两个对象是否相等
Set set=new HashSet();
String s1=new String("java");
String s2=s1;
String s3=new String ("java");
set.add(s1);
set.add(s2);
set.add(s3);
System.out.println(set.size());
2.实用类
枚举 enum 用来存常量 是一种类型
包装类 Interger
Integer.parseInt("6");
String
String str="abc";
String str1 = new String("abc");
System.out.println(str==str1);//false
System.out.println(str.equals(str1));//true
length();字符串长度
subString(start,end); 截取字符串 包前不包后
str.indexOf("a");
//查找字符返回下标,找不到返回-1;
str.split(",");//分割 返回时String[] 数组
str.trim();//去空格
str.equalsIgnoreCase("");//忽略大小写
str.toLowerCase();//小写
str.toUpperCase();//大写
str.replace("oldChar", "newChar");//替换
StringBuffer String StringBuilder String是不可变对象 final 类 对字符串频繁修改（如字符串连接）时，使用StringBuffer类可以大大提高程序执行效率
StringBuffer 线程安全 StringBuilder 线程不安全
Date
// 创建日期对象
Date date = new Date();
// 定制日期格式
SimpleDateFormat formater = new SimpleDateFormat("yyyy- MM-dd HH:mm:ss");
//format把data类型转换成String类型
String now = formater.format(date);
//parse把String类型转换成Date类型
date = formater.parse("2017-06-08 12:00:00");
Calendar 日历类
abstract 抽象类 Calendar calendar = Calendar.getInstance();
calendar.get(Calendar.DATE);
3.File IO
字节流和字符流相互转换 可以解决乱码问题
FileInputStream file = new FileInputStream("D:\\aaa\\aaa.txt");
InputStreamReader ir = new InputStreamReader(file,"utf-8");
BufferedReader br = new BufferedReader(ir);
字符流 所有的字符流都继承Reader Wirter
FileReader BufferedReader
Reader Wirter 读取文件类容是,使用FileReader fr = new FileReader("D:\\aaa\\aaa.txt");
BufferedReader br = new BufferedReader(fr);
FileWriter fw = new FileWriter("D:\\aaa\\cc.txt");
BufferedWriter bw = new BufferedWriter(fw);
String str = br.readLine();
StringBuffer sb = new StringBuffer();
while(str!=null){
sb.append(str);
bw.write(str);
str = br.readLine();
}
System.out.println(sb.toString());
bw.close();
br.close();
字节流 ,所有的字节流,都继承于 InputStream outputStream
子类 FileInputStream DataInputStream
拷贝 不需要读取文件内容是 用字节流 FileInputStream input = new FileInputStream("D:\\aaa\\tuzideng1.jpg");
DataInputStream finput = new DataInputStream(input);
FileOutputStream out = new FileOutputStream("D:\\aaa\\tuzideng2.jpg");
DataOutputStream fout = new DataOutputStream(out);
//缓存
byte[] bytes = new byte[1024];
while (finput.read(bytes) != -1) {
fout.write(bytes);
}
finput.close();
fout.close();
File类常用方法
boolean exists( ) 判断文件或目录是否存在
boolean isFile( )
boolean isDirectory( )
String getPath( )
String getAbsolutePath( )
String getName( )
boolean delete( )
boolean createNewFile( )
long length()
mkdirs()
反射机制
反射机制是指在运行状态中，动态的获取信息以及动态调用对象方法的功能
Java反射机制提供如下功能：
在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判段任意一个类所具有的成员变量和方法
在运行时调用任一个对象的方法
反射的基本应用
1.获得Class对象
//第一种方式：
Class c1 = Class.forName("demo.Student");
//第二种方式：
//java中每个类型都有class 属性.
Class c2 = Student.class;
//第三种方式：
//java语言中任何一个java对象都有getClass 方法
Student stu = new Student();
Class c3 = stu.getClass(); //c3是运行时类
2.判断是否为某个类的实例
Student stu = new Student();
Student.class.isInstance(stu);
3.创建实例
1使用Class对象的newInstance()方法来创建Class对象对应类的实例。
Class c1 = Student.class;
Class c1 = Student.class;
Object obj = c1.newInstance();
Student stu = (Student)obj;
2先通过Class对象获取指定的Constructor对象，来创建实例。这种方法可以用指定的构造器构造类的实例。
4.获取方法
5.获取构造器信息
6.获取类的成员变量（字段）信息
7.调用方法
8.利用反射创建数组
多线程
Java中创建线程的两种方式
继承java.lang.Thread类
// 重写run()方法
public void run() {
for (int i = 1; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start(); // 启动线程}
}
实现java.lang.Runnable接口
public class MyRunnable implements Runnable {
public void run() {
for (int i = 1; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread myThread = new Thread(myRunnable);
myThread.start(); // 启动线程}
}
}
线程的状态
线程调度方法
setPriority(int newPriority) 更改线程的优先级
线程优先级由1~10表示，1最低，默认优先级为5
优先级高的线程获得CPU资源的概率较大
public class MyThread extends Thread {
// 重写run()方法
public void run() {
for (int i = 1; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
public static void main(String[] args) {
Thread t1 = new Thread(new MyThread(), "线程A");
Thread t2 = new Thread(new MyThread(), "线程B");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
// 省略代码……
}
}
static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠
让线程暂时睡眠指定时长，线程进入阻塞状态
睡眠时间过后线程会再进入可运行状态
public class Wait {
public static void bySec(long s) {
for (int i = 0; i < s; i++) {
System.out.println(i + 1 + "秒");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
void join() 等待该线程终止
使当前线程暂停执行，等待其他线程结束后再继续执行本线程
public class MyThread implements Runnable {
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 输出当前线程的信息
System.out.println(Thread.currentThread().getName() + "运行：" + i);
}
}
public static void main(String[] args) {
System.out.println("*****线程强制执行******");
// 创建子线程并启动
Thread temp = new Thread(new MyThread());
temp.start();
for (int i = 0; i < 20; i++) {
if (i == 5) {
try {
// 阻塞主线程，子线程强制执行
temp.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "运行：" + i);
}
}
}
static void yield() 暂停当前正在执行的线程对象，并执行其他线程
暂停当前线程，允许其他具有相同优先级的线程获得运行机会
该线程处于就绪状态，不转为阻塞状态
只是提供一种可能，但是不能保证一定会实现礼让
public class MyThread implements Runnable {
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + "正在运行：" + i);
if (i == 3) {
System.out.print("线程礼让：");
Thread.yield();
}
}
}
public static void main(String[] args) {
MyThread my = new MyThread();
Thread t1 = new Thread(my, "线程A");
Thread t2 = new Thread(my, "线程B");
t1.start();
t2.start();
}
}
void interrupt() 中断线程
boolean isAlive() 测试线程是否处于活动状态
线程通信方法
wait() 调用wait()方法会挂起当前线程，并释放共享资源的锁
notify() 调用任意对象的notify()方法会在因调用该对象的wait()方法而阻塞的线程中随机选择一个线程解除阻塞，但要等到获得锁后才可真正执行
notifyAll() 调用了notifyAll()方法会将调用该对象的wait()方法而阻塞的所有线程一次性全部解除阻塞
wait(),notify(),notifyAll()这三个方法都是Object类当中的final方法，被所有类继承且不允许重写。这三个方法只能在同步方法或者同步代码块中使用，否则会抛出异常
线程同步方法synchronized
就是为当前的线程声明一个锁
使用synchronized修饰的方法控制对类成员变量的访问
使用synchronized修饰的方法控制对类成员变量的访问
访问修饰符 synchronized 返回类型 方法名（参数列表）{……}
或者
synchronized 访问修饰符 返回类型 方法名（参数列表）{……}
使用synchronized关键字修饰的代码块
synchronized(syncObject){
//需要同步的代码
}
java网络编程 http
Socket
基于TCP协议的Socket网络通信
用来实现双向安全连接网络通信
进行网络通信时，Socket需要借助数据流来完成数据的传递工作
客户端
public class ClientLogin {
public static void main(String[] args) {
//1.创建一个socket对象（指定服务器IP,端口号）
try {
Socket socket = new Socket("localhost",8000);
//2.打开输出 流,发送请求
OutputStream os = socket.getOutputStream();
InputStream is = socket.getInputStream();
String info = "用户名：TOM，密码：1234";
os.write(info.getBytes());
socket.shutdownOutput();
//服务器接收客户端反馈
BufferedReader br = new BufferedReader(new InputStreamReader(is));
info = "";
while((info=br.readLine())!=null){
System.out.println("我是客户端，服务器的响应是："+info);
}
os.close();
is.close();
socket.close();
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//3.关闭资源
}
}
服务端
public class ServerLogin {
public static void main(String[] args) {
//1.创建一个ServerSocket对象 指定端口号
try {
ServerSocket serversocket = new ServerSocket(8000);
//2.监听客户端请求
Socket socket = serversocket.accept();
//3.打开输入流，处理用户请求
InputStream is = socket.getInputStream();
OutputStream os = socket.getOutputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
String info = null;
while((info=reader.readLine())!=null){
System.out.println("我是服务器，客户端信息为："+info);
}
socket.shutdownInput();
//服务器给客户端一个响应
//1.打开输出流，发送数据
info = "欢迎您，登录成功！";
os.write(info.getBytes());
//4.关闭资源
reader.close();
is.close();
os.close();
socket.close();
serversocket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
http
超文本传输协议（HTTP，HyperText Transfer Protocol)是互联网上应用最为广泛的一种网络协议
HTTPS（全称：Hyper Text Transfer Protocol over Secure Socket Layer），是以安全为目标的HTTP通道，简单讲是HTTP的安全版。即HTTP下加入SSL层，HTTPS的安全基础是SSL，因此加密的详细内容就需要SSL。
xml
DOM
基于XML文档树结构的解析
适用于多次访问的XML文档
特点：比较消耗资源
读取dom
DocumentBuilderFactory bf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = bf.newDocumentBuilder();
Document doc = db.parse("src/phones.xml");
读取节点的属性，和文本
NodeList brandList = doc.getElementsByTagName("Brand");
for (int i = 0; i < brandList.getLength(); i++) {
Node brand = brandList.item(i);
Element element = (Element) brand;
String attrValue = element.getAttribute("name");
NodeList types = element.getChildNodes();
System.out.println(types.getLength());
for (int j = 0; j < types.getLength(); j++) {
if (types.item(j).getNodeType() == 1) {
Element typeElement = (Element) types.item(j);
String type = typeElement.getTextContent();
System.out.println("手机:" + attrValue + type);
}
}
}
创建节点，属性，文本
Element brandElement = doc.createElement("Brand");
brandElement.setAttribute("name", "MOTO");
Element type = doc.createElement("type");
type.setTextContent("A1680");
brandElement.appendChild(type);
Element pe = (Element) doc.getElementsByTagName("PhoneInfo").item(0);
pe.appendChild(brandElement);
保存xml
TransformerFactory tf = TransformerFactory.newInstance();
Transformer transformer = tf.newTransformer();
DOMSource domSource = new DOMSource(doc);
transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8");
FileOutputStream fos = new FileOutputStream("src/phones1.xml");
StreamResult result = new StreamResult(fos);
transformer.transform(domSource, result);
DOM4J
非常优秀的Java XML API
性能优异、功能强大
开放源代码
读取dom
SAXReader saxReader = new SAXReader();
Document document = saxReader.read("NewFile.xml");
读取节点的属性，和文本
Element root =document.getRootElement();
List<Element> brandList = root.elements();
for(Element brand:brandList) {
Attribute attr= brand.attribute("name");
System.out.println(attr.getValue());
List<Element> typeList = brand.elements();
for(Element type:typeList) {
System.out.println(type.getText());
}
}
创建节点，属性，文本
Element newBrand = root.addElement("Brand");
newBrand.addAttribute("name", "小米");
Element newType = newBrand.addElement("type");
newType.setText("小米6");
保存xml
OutputFormat format =OutputFormat.createCompactFormat();
format.setEncoding("gb2312");
FileWriter file = new FileWriter("phones2.xml");
XMLWriter writer = new XMLWriter(file,format);
writer.write(document);
writer.close();
0 条评论
下一页
