JavaSe的一些重要内容

###02常用的DOS命令
* A: 常用的DOS命令
* a: 打开Dos控制台
* win+r--cmd--回车
* b: 常用dos命令
* cd.. : 退回到上一级目录
* cd\  : 退回到根目录
* cd tools: 进入tools文件夹
* d:   : 回车 盘符切换
* cd d:\234 :进入d盘的234文件夹,再切换盘符(d:)才能进入d:\234
* dir  : 列出当前目录下的文件以及文件夹
* cls  : 清除屏幕
* ipconfig: 查看本机的相关网络配置
* c: dos控制台运行记事本程序
* D:\>C:\windows\notepad.exe
* 还可以省略“.exe”后缀，例如：D:\>C:\windows\notepad

* 1：单行注释    //注释内容
* 2：多行注释    /*注释内容*/
* 3：文档注释 /**注释内容*/

* 1：对于单行和多行注释，被注释的文字，不会被JVM解释执行
* 2：对于文档注释，可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档
* 3：单行注释可以嵌套使用，多行注释不能嵌套使用

* B:Java中数据类型的分类
* 基本数据类型: 基本数据类型是Java语言中内置的类型，分别是整数类型、小数类型、字符类型、布尔类型。
这四类基本类型是最简单、最基础的类型。
* 整数(byte、short、int、long)、小数(float、double)、字符类型(char)、布尔类型(boolean)
* 引用数据类型: 是强大的数据类型，它是基于基本数据类型创建的。JavaSE中提供了一个超级类库，类库中包含了近万种引用数据类型。
不过现在我们先要学习的是基本类型！
* 数组、类、接口

###15Java中的常量
* A: 常量的定义
* 常量就是不变的数据量, 在程序执行的过程中其值不可以发生改变
* B: 常量分类
* a: 整数类型
* 十进制表示方式：正常数字   如 13、25等
* 二进制表示方式：以0b(0B)开头    如0b1011 、0B1001 
* 十六进制表示方式：以0x(0X)开头   数字以0-9及A-F组成  如0x23A2、0xa、0x10 
* 八进制表示方式：以0开头   如01、07、0721
* b: 小数类型
* 如1.0、-3.15、3.168等
* c: 布尔类型
* true、false
* d: 字符类型
* 如'a','A', '0', '家'
* 字符必须使用’’ 包裹，并且其中只能且仅能包含一个字符。
* e: 字符串类型
* 字符串String类型是一种引用类型，我们先了解作为常量类型的使用方式
* 如“我爱Java”，“0123”，“”，“null”
* 字符串必须使用“”包裹，其中可以包含0~N个字符。

整数常量可以根据所在范围来确定类型
你可能会认为12345678901在-263~263-1之间，所以它是long类型
Java中整数常量如果不在-2147483648~2147483648之间就必须添加“L”后缀
在-2147483648~2147483648之间的也可以添加“L”后缀
float类型常量必须添加“F”后缀（小写也可以，但建议使用大写）java中默认的浮点类型是double类型


===========================================
创建变量:
数据类型  变量名  =  数据值;
变量不赋值，不能被使用

类型转换:
byte -> short -> int -> long -> float -> double
自动类型转换:int i = 100;
   double d2 = i;
强制类型转换:int  i = (int)6.718;

运算符:
“%”小数取余没有意义
赋值运算符
  +=, -=, *=, /=, %=  
比较运算符
逻辑运算符
& | ^ ！  逻辑运算符通常连接两个其他表达式计算后的布尔值结果
短路与或者短路或时，只要能判断出结果则后边的部分就不再判断：&& ||

三元运算符
(条件表达式)？表达式1：表达式2


===============================
引用数据类型:
数据类型  变量名  =  new 数据类型();
变量名.方法名();
import java.util.Scanner

Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String str = sc.next();

import java.util.Random

Random rm = new Random();
int i = r.nextInt(100); //产生一个0到100的整数
double d =r.nextDouble(); //产生一个0到1.0

控制语句:if while for switch


封装|继承|多态:
public protected 友好 private


final 方法可以被继承，但不能被覆盖


final person地址不能变


继承：


同名变量：看等号左边类型
同名方法：看等号右边类型


static 可以被继承


内部类：
成员内部类：
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
局部内部类：
class Party {


public void puffBall(){


class Ball {
              public void puff(){
    System.out.println("气球膨胀了");
}
}


new Ball().puff();
}
}


//构造代码块  优先于构造方法执行  每创建一个对象均会执行一次构造代码块
{
System.out.println("构造代码块执行了");
}


//静态代码块  优先于主方法执行、优先于构造代码块 只执行一次  可用于给静态变量赋值
static{
System.out.println("静态代码块执行了");
}


Ctrl+T：查看所选中类的继承树
Ctrl+滑动鼠标点击类名看所选中类的源代码


/**
 * 我的工具类
 * @author Li
 * @version 1.0版本
 */
public class Tool {
/**
* 返回两个整数的累加和
* @param num1 第一个数
* @param num2 第二个数
* @return 返回累加和
*/
public static int getSum(int num1, int num2){
return num1 + num2;
}
}


===========equals方法的重写
class Person extends Object{
int age ;
public boolean equals(Object obj) {
//判断当前调用equals方法的对象和传递进来的对象是否是同一个
if(this == obj){
return true;
}
//判断传递进来的对象是否是Person类型
if(!(obj instanceof Person)){
return false;
}
//将obj向下转型为Perosn引用，访问其属性
Person p = (Person)obj;
return this.age == p.age;
}
}


===========正则表达式
\\d表示[0-9]
\\w表示[a-zA-Z_0-9]
\\.
^表示行开头
$表示行结尾 ^[abc][0-9]$
?表示出现0或1次
*表示0或多次
+表示1次或多次
{n}表示n次
{n,}至少n次
{n,m}表示n到m次


================Arrays
String toString(int[] a)
int binarySearch(int[] a)
void sort(int[] a)
===
BigInteger(String val)
BigDecimal(String val)


=============集合
ArrayList list = new ArrayList();
Collection
List可以有重复的元素
ArrayList 元素增删慢，查找快
LinkedList 方便元素添加、删除的集合,查找慢
Set不有重复的元素
HashSet 元素唯一 没有顺序的
如果两个对象hashCode方法算出结果一样，这样现象称为哈希冲突，
这时会调用对象的equals方法，比较这两个对象是不是同一个对象，如果equals方法返回的是true，
那么就不会把第二个对象存放在哈希表中，如果返回的是false，就会把这个值存放在哈希表中。
Student重写:int hashCode()  boolean equals(Object obj)
hs.add(new Student("zhangsan",21));
。。。
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}


LinkedHashSet 保证有序存入和取出的顺序一致


Iterator it =coll.iterator()
Iterator：hasNext()，next()




泛型类:
class ArrayList{ }
泛型的方法:
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }
public T[] toArray(T[] a){  } 
泛型的接口:
public interface List {
         abstract boolean add(E e);
        }
实现类,实现接口的同时,也指定了数据类型
public class XXX implements List{
       }




泛型的通配符
public class GenericDemo {
    public static void main(String[] args) {
      ArrayList array = new ArrayList();
      
      HashSet set = new HashSet();
      
      array.add("123");
      array.add("456");
      
      set.add(789);
      set.add(890);
      
      iterator(array);★★
      iterator(set);
    }
    /*
     *  定义方法,可以同时迭代2个集合
     *  参数: 怎么实现 , 不能写ArrayList,也不能写HashSet
     *  参数: 或者共同实现的接口
     *  泛型的通配,匹配所有的数据类型  ?
     */
    public static void iterator(Collection coll){
      Iterator it = coll.iterator();
      while(it.hasNext()){
        //it.next()获取的对象,什么类型
        System.out.println(it.next());
      }
    }
   }


泛型的限定 
public class GenericTest {
    public static void main(String[] args) {
      //创建3个集合对象
      ArrayList cs = new ArrayList();
      ArrayList fwy = new ArrayList();
      ArrayList jl = new ArrayList();
      
      //每个集合存储自己的元素
      cs.add(new ChuShi("张三", "后厨001"));
      cs.add(new ChuShi("李四", "后厨002"));
      
      fwy.add(new FuWuYuan("翠花", "服务部001"));
      fwy.add(new FuWuYuan("酸菜", "服务部002"));
      
      jl.add(new JingLi("小名", "董事会001", 123456789.32));
      jl.add(new JingLi("小强", "董事会002", 123456789.33));
      
   //   ArrayList arrayString = new ArrayList();
      iterator(jl);
      iterator(fwy);
      iterator(cs);
    
    }


   public static void iterator(ArrayList array){
      
       Iterator it = array.iterator();
       while(it.hasNext()){
         //获取出的next() 数据类型,是什么Employee
         Employee e = it.next();
         e.work();
       }
    }
   }


======
Map不能包含重复的键，值可以重复（key需要重写键的hashCode()方法、equals()方法）


HashMap存取顺序不能保证一致


LinkedHashMap存取顺序一致


put() get() ketSet() 
Set> entrySet = map.entrySet();
for (Map.Entry entry : entrySet) {
Student key = entry.getKey();
String value = entry.getValue();
}


Collections.shuffle( list );
Collections.sort( list );


集合嵌套


=============
Throwable: 它是所有错误与异常的超类（祖宗类）
|- Error 错误
|- Exception 编译期异常,进行编译JAVA程序时出现的问题
|- RuntimeException 运行期异常, JAVA程序运行过程中出现的问题


=========文件过滤器


class MyFileFilter implements FilenameFilter{
public boolean accept(File dir, String name) {
return name.endsWith(".java");
}
}
File[] files = file.listFiles(new MyFileFilter());




class FileFileterByDir implements FileFilter{
public boolean accept(File pathname) {
return pathname.isDirectory();
}
}


=====字符转换流 
字节流+编码表
FileOutputStream fos = new FileOutputStream("c:\\cn8.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
InputStream in = new FileInputStream("c:\\cn8.txt");
InputStreamReader isr = new InputStreamReader(in,"utf-8");


BufferedInputStream 
BufferedReader：readLine()




==========
Properties(key,value) 类表示了一个持久的属性集
没有泛型。键值都是字符串,Hashtable的子类
load(InputStream) 件中的数据，读取出来，保存到Propertie集合
load(Reader)
store(OutputStream,commonts) 集合中的数据，保存到指定的流所对应的文件
store(Writer,comments)       prop.store(out, "save data");


setProperty(String key, String value)
getProperty(String key)
Set stringPropertyNames() 返回key的集合


=============
对象序列化流ObjectOutputStream
writeObject(new Person("wangcai",20));
class Person implements Serializable{}
对象反序列化流ObjectInputStream
Person obj = (Person)ois.readObject();


Serializable接口：
private static final long serialVersionUID = 1L;  //给类显示声明一个序列版本号。
关键字transient修饰，static修饰不会被序列化

=======
打印流；
PrintStream|PrintWriter：
PrintWriter out = new PrintWriter("printFile.txt");
public PrintWriter(OutputStream out, boolean autoFlush)
public PrintWriter(Writer out, boolean autoFlush)
void print(String str)
void println(String str)
======
commons-IO：
FilenameUtils：
getExtension(String path)
getName()
isExtension(String fileName,String ext)
FileUtils
readFileToString(File file)
writeStringToFile(File file，String content)
copyDirectoryToDirectory(File srcDir,File destDir)
copyFile(File srcFile,File destFile)

=====================流总结
字节流
 字节输入流 InputStream
 FileInputStream 操作文件的字节输入流
 BufferedInputStream高效的字节输入流
 ObjectInputStream 反序列化流
字节输出流 OutputStram
 FileOutputStream 操作文件的字节输出流
 BufferedOutputStream 高效的字节输出流
 ObjectOuputStream 序列化流
 PrintStream 字节打印流
字符流
 字符输入流 Reader
 FileReader 操作文件的字符输入流
 BufferedReader 高效的字符输入流
 InputStreamReader 输入操作的转换流(把字节流封装成字符流)
字符输出流 Writer
 FileWriter 操作文件的字符输出流
 BufferedWriter 高效的字符输出流
 OutputStreamWriter 输出操作的转换流(把字节流封装成字符流)
 PrintWriter 字符打印流

=======================多线程
线程池:
Executors工厂类
ExecutorService：线程池类
Future接口:记录线程任务执行完毕后产生的结果

例:
ExecutorService service = Executors.newFixedThreadPool(2);
MyRunnable r = new MyRunnable(); //Runnable接口的实现类
service.submit(r);
service.submit(r);
service.shutdown();//线程回收
-----------------------------
ExecutorService service = Executors.newFixedThreadPool(2);
MyCallable c = new MyCallable(); //Callable接口的实现类,与Runnable类似，call方法可以抛出异常
Future result=service.submit(c);
Integer sum = result.get();
System.out.println("sum=" + sum);


service.shutdown();//线程回收
...
public Integer call() throws Exception {
return x+y;
}


线程同步:
1.同步代码块
synchronized (锁对象) {
可能会产生线程安全问题的代码
}
例:
public class Ticket implements Runnable {
//共100票
int ticket = 100;
//定义锁对象
Object lock = new Object();
@Override
public void run() {
//模拟卖票
while(true){
//同步代码块
synchronized (lock){
if (ticket > 0) {
//模拟电影选坐的操作
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
}
}
}
}
}


2.同步方法:
public synchronized void method(){
    可能会产生线程安全问题的代码
}
锁对象是 this

3.静态同步方法:
public static synchronized void method(){
可能会产生线程安全问题的代码
}
锁对象是 类名.class

线程的死锁:
public class MyLock {
public static final Object lockA = new Object();
public static final Object lockB = new Object();
}
public class ThreadTask implements Runnable {
int x = new Random().nextInt(1);//0,1
//指定线程要执行的任务代码
@Override
public void run() {
while(true){
if (x%2 ==0) {
//情况一
synchronized (MyLock.lockA) {
System.out.println("if-LockA");
synchronized (MyLock.lockB) {
System.out.println("if-LockB");
System.out.println("if大口吃肉");
}
}
} else {
//情况二
synchronized (MyLock.lockB) {
System.out.println("else-LockB");
synchronized (MyLock.lockA) {
System.out.println("else-LockA");
System.out.println("else大口吃肉");
}
}
}
x++;
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
//创建线程任务类对象
ThreadTask task = new ThreadTask();
//创建两个线程
Thread t1 = new Thread(task);
Thread t2 = new Thread(task);
//启动线程
t1.start();
t2.start();
}
}


Lock接口:(替代synchronized)
public class Ticket implements Runnable {
//共100票
int ticket = 100;

//创建Lock锁对象
Lock ck = new ReentrantLock();

@Override
public void run() {
//模拟卖票
while(true){
//synchronized (lock){
ck.lock();
if (ticket > 0) {
//模拟选坐的操作
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
}
ck.unlock();
//}
}
}
}


sleep: 不释放锁对象, 释放CPU使用权
在休眠的时间内，不能唤醒
wait(): 释放锁对象, 释放CPU使用权（由锁对象调用）
在等待的时间内，能唤醒


===================
JDBC
Class.forName("com.mysql.jdbc.Driver");
Connection con = DriverManager.getConnection(“jdbc:mysql://localhost:3306/mydb”,”root”,”root”);
Statement stmt = con.createStatement();
int executeUpdate(String sql) --执行insert update delete语句
ResultSet executeQuery(String sql); --执行select语句
boolean execute(String sql); --执行select返回true 执行其他的语句返回false
ResultSet
rs.next();
rs.getInt(1);
Object getObject(String name)....
rs.close();
stmt.close();
con.close();


Statement有SQL注入问题
PreparedStatement可以解决:
PreparedStatement psmt = conn.prepareStatement(sql)
setXxx(int index, Xxx xx)
executeUpdate(),executeQuery()

自定义JDBCUtils：
1.db.properties：
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mydb
user=root
password=root
2.
public class JDBCUtils {


private static String driver;
private static String url;
private static String user;
private static String password;
// 静态代码块
static {
try {
// 1 使用Properties处理流
// 使用load()方法加载指定的流
Properties props = new Properties();
Reader is = new FileReader("db.properties");
props.load(is);
// 2 使用getProperty(key)，通过key获得需要的值，
driver = props.getProperty("driver");
url = props.getProperty("url");
user = props.getProperty("user");
password = props.getProperty("password");
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static Connection getConnection() {
try {
// 1 注册驱动
Class.forName(driver);
// 2 获得连接
Connection conn = DriverManager.getConnection(url, user, password);
return conn;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}


====
DBUtils(commons-dbutils-1.6.jar)
 QueryRunner类
 ResultSetHandler接口
 DbUtils类
QueryRunner: 
new QueryRunner()
update(Connection conn, String sql, Object... params)
query(Connection conn, String sql, ResultSetHandler rsh, Object... params)

ResultSetHandler接口:
ArrayHandler 结果第一行放入数组
ArrayListHandler 每行
BeanHandler 第一行放入JavaBean(Serializable,无参构造,get,set)
BeanListHandler
ColumnListHandler 指定的列
ScalarHandler    单数据。例如select count(*) from
MapHandler
MapListHandler
=====
连接池DBCP,C3P0
public class JDBCUtils {
public static final String DRIVER = "com.mysql.jdbc.Driver";
public static final String URL = "jdbc:mysql://localhost:3306/daydb";
public static final String USERNAME = "root";
public static final String PASSWORD = "root";
/*
* 创建连接池BasicDataSource
*/
public static BasicDataSource dataSource = new BasicDataSource();
//静态代码块
static {
//对连接池对象 进行基本的配置
dataSource.setDriverClassName(DRIVER); // 这是要连接的数据库的驱动
dataSource.setUrl(URL); //指定要连接的数据库地址
dataSource.setUsername(USERNAME); //指定要连接数据的用户名
dataSource.setPassword(PASSWORD); //指定要连接数据的密码
}
/*
* 返回连接池对象
*/
public static DataSource getDataSource(){
return dataSource;
}
}
使用:


QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
query(String sql, ResultSetHandler rsh, Object... params)
update(sql,params);

==============Socket
InetAddress:
static InetAddress getByName(String host)
static InetAddress getLocalHost()
String getHostName();
String getHostAddress();
UDP:无连接通信协议,可能丢失
集装箱:
DatagramPacket(byte[] buf,int len); //接受
DatagramPacket(byte[] buf,int len,InetAddress ip,int port); //发送
InetAddress getAddress();
int getPort();
byte[] getData();
int getLength();
码头：
DatagramSocket(); //绑定到本地主机任意可用端口
DatagramSocket(int port);
receive(DatagramPacket p);
send(DatagramPacket p);

TCP:
服务端：
ServerSocket(int port)
Socket accept()
InetAddress getAddress()
客户端:
Socket(String host,int port);
Socket(InetAddress ip,int port);
getPort()
InetAddress getLocalAddress()
close()
InputStream getInputStream()
OutputStream getOutputStream()

===============反射
获取反射的三种方法:
Person p = new Person();  Class c2 = Person.class;   Class c3 = Class.forName("Person");
Class c = p.getClass();
Class的方法:
Constructor getConstructor(Class... parameterTypes)  //获取public修饰, 指定参数类型所对应的构造方法
getDeclaredConstructor(Class... parameterTypes)  //获取指定参数类型所对应的构造方法(包含私有的)
getConstructors()                     //获取所有public构造函数
getDeclaredConstructor()


public Field getField(String name)....

public Method getMethod(String name, Class... parameterTypes)....

方法类Constructor：
public T newInstance(Object... initargs)  setAccessible(true);//取消 Java 语言访问检查
例如:
Constructor con = c.getDeclaredConstructor(String.class, int.class);
con.setAccessible(true);//取消 Java 语言访问检查
Object obj = con.newInstance("小明", 23);
Field类:
Object obj = con.newInstance("小明");
//4，获取指定的成员变量
//public String name;
Field nameField = c.getField("name");
//public int age;
Field ageField = c.getField("age");
//private String address;
Field addressField = c.getDeclaredField("address");
addressField.setAccessible(true); //取消 Java 语言访问检查

//5，通过方法，给指定对象的指定成员变量赋值或者获取值
System.out.println("name = "+ nameField.get(obj));
System.out.println("age = "+ ageField.get(obj));
System.out.println("address = "+ addressField.get(obj));

//赋值
ageField.set(obj, 23);
addressField.set(obj, "凯利广场");


Method类:
 public Object invoke(Object obj,  Object... args) 




==============================动态代理
public interface IBoss {


public void yifu();

public String xiezi(String size);
}




public class Boss implements IBoss {


public void yifu() {
System.out.println("天猫超市衣服，就是好，大家快来嘛！！！");
}

public void kuzi(){
System.out.println("买衣服送裤子了!!!");
}



public String xiezi(String size) {

return "鞋子尺寸:"+size+"什么颜色都有";
}


}




public class Test {


public static void main(String[] args) {


/////////////////代理的创建
IBoss proxyBos = (IBoss) Proxy.newProxyInstance(Boss.class.getClassLoader(), new Class[] {IBoss.class}, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//加强的方法
if("yifu".equals(method.getName())){
System.out.println("今天双十一，大甩卖!!!");
return method.invoke(new Boss(), null);

}
//不用加强的方法
return method.invoke(new Boss(), args);
}
});
/////////////////////////////////代理的使用
proxyBos.yifu();
System.out.println(proxyBos.xiezi("xxl"));
}

}






============如何将自定义类转成byte[](序列化)
BufferArrayOutputStream bo = new BufferArrayOutputStream() //内存流
ObjectOutputStream oo = new ObjectOutputStream(bo);
oo.writeObject(person)
byte[] b = bo.toByteArray();


反序列化:
BufferArrayInputStream bi = new ByteArrayInputStream(b);
ObjectInputStream os = new ObjectInputStream(bi);
person=os.readObject();




==========注意:
class myClass{
private static FlowBean bean = new FlowBean();
private ArrayList list = new ArrayList();
public void test(){
bean.setUp(1);
bean.setD(2);
list.add(bean);


bean.setUp(10);
bean.setD(20);
list.add(bean);




bean.setUp(100);
bean.setD(200);
list.add(bean);


}


main(){


for(FlowBean f : list){
System.out.println(f); 
//将会输出 100 200 100 200 100 200 因为指向的是同一个内存地址!!!
}
}
}


==========
BeanUtils.copyProperties(obean, bean);


==========json转bean
public String evaluate(String jsonLine){
ObjectMapper oMap = new ObjectMapper();
MovieRateBean bean = oMap.readValue(jsonLine,MovieRateBean.class);
return bean.toString();
}