JavaSE基础

String类和StringBuffer类中的部分方法

Java的API:Application(应用) Programming(程序) Interface(接口)

★Object类为所有类的父类

★public boolean equals(Object obj)
{
return this==obj;
}
以上为equals()方法源码，其中，谁调用的equals方法谁就是this

String（字符串）类中的部分方法:
★String s=“abc”;
System.out.println(s);
其实第二行输出的变量s的后面隐藏了toString()方法，即s.toString()

indexOf(String s) 返回字符串第一次出现的索引

substring(int i,int j) 截取 例:String s1=“kawayi”;
String s2=s1.substring(2);
System.out.println(s2);
结果为:wayi

StringBuffer（字符串缓冲区）类中的部分方法:
append(任意类型参数) 添加
delete(int i,int j) 删除i到j之间的元素（索引j处元素不会被删除!）
insert(int i,任意类型参数) 添加（参数添加到索引i处元素的前面）
replace(int i,int j,String s) 去掉索引i到j（包含i和j）之间的元素，s替换
reverse() 反转

★绝大部分索引包含头不包含尾
例:String s1=“xixia”;
String s2=s1.delete(1,4);
System.out.println(s2);
结果为xa，并不是x
但如果把第二行代码改成
String s2=s1.delete(0,4);
结果会变成整个字符串被删除

★StringBuilder类的方法和StringBuffer类一样，但StringBuilder类比StringBuffer类运行要快。只不过在多线程里面StringBuilder类不能保证同步

Integer类、System类、Math类、Arrays类

★int i=Integer.parseInt(“12”);
System.out.println(i/2);
结果为6
parseInt()方法为静态方法，用法是将字符串类型转换成int类型

★int i=3;
String s=i+"";
System.out.println(s+1);
结果为31，并不是4，int类型加上""就会变成String类型

或
String s=Integer.toString(5);
这行代码也能将int类型转换成String类型

★System类里的方法都是静态方法
long i=System.currentTimeMills();查看当前系统毫秒值

System.exit(0);终止程序，即不再运行，0代表正常终止

System.gc();回收垃圾对象

System.arraycopy(原数组名，原数组调用处索引，其他数组名，其他数组添加处索引，调用个数);

★Math类里的方法都是静态方法（数学计算方法）

★Arrays类（数组工具类）

Date日期类和Calendar日历类

java时间原点：1970年1月1日，00:00:00

★最原始的toString()方法，返回的是地址值，被重写了的话，就会返回所写相关内容

★Date date=new Date();
long time=date.getTime();
System.out.println(time);
时间输出为毫秒值

SimpleDateFormat sdf=new SimpleDateFormat(“yyyy年MM月dd日HH点mm分ss秒”);
因为DateFormat类是抽象类，不能创建对象，所以用它的子类SimpleDataFormat
String date=sdf.format(new Date());
System.out.println(date);
时间输出为自己规定好的格式
上述方法String format(Date date)

SimpleDateFormat sdf=new SimpleDateFormat(“yyyy年MM月dd日HH点mm分ss秒”);
Date date=sdf.parse(“1997年09月06日19点51分55秒”);
System.out.println(date);
时间输出为标准格式

★format()方法–>将Date类型转换为String类型
parse()方法–>将String类型转换为Date类型

Calendar类
Calendar c=Calendar.getInstance();//获取数据
c.get(Calendar.MONTH)获取
c.set(Calendar.MONTH,9)赋值

静态-final-内部类

★被final修饰的变量，不能再次被赋值，原本的值也不会改变（final也可以修饰方法和类）

★被静态static修饰的成员变量，可以直接被类名调用

★在静态中不能调用非静态

★静态中不能使用this和super

★接口中的成员变量已经是静态常量，都默认使用public static final修饰

★成员内部类在方法外，局部内部类在方法内（小括号里面）
调用成员内部类方法：外部类名.内部类名 变量名=new 外部类名（）.new 内部类名（）； 变量名.内部类方法；
调用局部内部类方法：要在包含局部内部类的方法里局部内部类外调用-> 内部类名 变量名=new 内部类名（）； 变量名.内部类方法；

★访问修饰符(权限由高到低):public>protected(本包中的类和其他包中的子类，不能修饰类!)>default(本包中的类)>private(本类中，也不能用来修饰类)

快捷查看键-创建java文档或jar包

★类名 Ctrl+T 查看继承的类
方法名 Ctrl 查看位置和内容
F3 源码

★java.lang包中的包不需要导入，可以直接用

★/**

*/
以上为文档注释

★右键项目->点击export->点击java文件夹->jar为生成jar包，doc为生成注释文档

★抽象类和接口都不能创建对象，抽象类中可以有普通方法，普通类中不能有抽象方法，接口中的方法都为抽象方法

Exception异常

★Throwable类是Java语言中所有错误或异常的超类

★抛出异常之后，异常调用者不处理的话，程序将无法编译

★throw new Exception(或者Exception的子类)（“该程序有异常”）;

throws Exception(或者Exception的子类)抛出异常（写法：跟在方法后面，可以写多个，用","连接，throws写一个就行了，抛几个异常就得有几个捕获异常，即几个try…catch）

★try
{
有异常的代码块
} -->声明此处有异常
catch（异常类名 变量名）
{
处理异常的代码块
} -->捕获异常并处理

★运行时异常:如果抛出的异常是RuntimeException类（包括其子类），那么就不需要声明“throw 异常类名”语句，也不需要“try 。。。catch。。。”语句

★Throwable类中的printStackTrace方法：将异常信息追踪到标准的错误流（即异常的详细信息）

MySQL数据库_1

结构化查询语言SQL（Structured Query Language）

★exit 退出MySQL

★create database 数据库名; //创建数据库
use 数据库名;
show databases(tables); //查看所有数据库(表)
drop database(table) 数据库名(表名); //删除数据库(表)
desc 表名; //查看表

★主键约束:primary key
自增长:auto_increment

★列操作

添加新列(add)
alter table 表名 add 列名 数据类型 约束;
alter table mytable add name varchar(10) primary key;

修改原有列的数据类型和约束(modify)
alter table 表名 modify 列名 数据类型 约束;
alter table mytable modify name varchar(10);

修改原有列的列名(change)
alter table 表名 change 旧列名 新列名 数据类型 约束;

删除列(drop)
alter table 表名 drop 列名;

★表操作

修改表名
rename table 原名 to 新名;

向表中添加数据
insert into 表名(列名1，列名2，列名3) values(值1，值2，值3);
或
insert into 表名 values(值1，值2，值3);

批量添加
insert into 表名(列名1，列名2，列名3) values(值1，值2，值3),(值1，值2，值3),(值1，值2，值3);

更新数据
update 表名 set 列名=所改数据内容 where 列名=值;
update mytable set age=19 where id=1;

查询数据
select 列名或列名1，列名2… from 表名 where 条件;
例:select id,name,age from mytable;
select * from 表名; 查看所有列的数据
关键字distinct用来去除重复数据
select id as iid from mytable; 查询结果将列名"id"临时显示为"iid",原始列名不会变

删除行数据
delete from 表名 where 条件;

注：不等于为“<>” 例:a<>1
其他运算符:<，>，=，<=，>=

between...and...的用法：
select * from mytable where age between 1 and 19;（也可用于日期）

in的用法：
update mytable set age=19 where id in(1,2,3,4,5);
update mytable set age=19 where id not in(1,2,3,4,5);

like的用法：
select * from mytable where name like '%丽';
查询不管前面是什么内容，只要最后的是'丽'的结果

select * from mytable where name like '%丽%';
查询包含'丽'的结果

select * from mytable where name like '_';
查询长度为1的结果，一个下划线'_'代表一个长度

MySQL数据库_2

★排序查询desc/asc
order by 列名 desc(降序)/asc(升序)
select * from mytable order by age desc;
注：不标明的话默认升序asc

★聚合函数
select count(*) from mytable; 得出表中的行数

select sum(列名) from mytable; 对列的数据求和

select max/min(列名) from mytable; 得出列中的最大值/最小值

select avg(列名) from mytable; 对列的数据求平均值

Collection集合

★集合类必须存储对象类型数据，不能存储基本类型数据，但是1.4版本之后会自动装箱拆箱

★Collection接口是层次结构中的根接口
它的子接口有List接口（里面有ArrayList类和LinkedList类，有序可重复）和Set接口（里面有HashSet类，无序不可重复）

集合名.add(); 添加
集合名.clear(); 移除所有元素
集合名.contains(“xiaosan”); 判断元素xiaosan是否在集合当中，方法类型为boolean
集合名.size(); 返回集合中元素数量
集合名.remove(“haha”); 移除元素haha，方法类型为boolean，移除了返回true，反之false，如果有相同元素，则移除第一个

★迭代器(可用于任何类型集合的遍历)
Iterator it=集合名.iterator();
while(it.hasNext())hasNext()方法判断集合中是否还有元素,方法类型为boolean
{
String s=it.next();
System.out.println(s);打印集合中各个元素
}

★增强for循环
for（数据类型 变量名(随便起)：数组名或集合名）
{
System.out.println(变量名);
}

List接口

★List接口中的方法
E remove(int i)
移除索引i处的元素，并返回被移除元素的值
例：List list=new ArrayList(); //为泛型
list.add(1.1);
list.add(1.2);
list.add(1.3);
list.add(1.4);
Double b=list.remove(0);
System.out.println(b);
System.out.println(list);
结果为: 1.1
[1.2,1.3,1.4]

remove(Object o)
移除元素，移除成功返回true，反之false

E set(int i,E)
将i索引上的元素更改为E（注意元素类型不能改变)，并返回被修改之前的元素

get(int i)
获得索引i处的元素

★遍历集合的过程中，不允许进行修改集合长度（如进行添加、删除）的操作

★数据的存储结构
堆栈：先进后出
队列：先进先出
数组：查找快，增删慢
链表：查找慢，增删快

★查询用ArrayList 增删用LinkedList

Set接口

Set接口里的集合没有索引，目前只能用迭代器或增强for循环遍历

HashSet类和ArrayList类代码编写相同

★LinkedHashSet类继承HashSet类，有序，不允许有重复元素

★hashCode和equals方法快捷输入：alt+shift–>选择对应的选项

Map集合

Map中的键K和值V，键不可重复，值可重复
HashMap类是无序的，它的子类LinkedHashMap是有序的

★方法put(K,V) 添加
Map map=new HashMap();//推荐加上泛型
map.put(“a”，20);

★方法get(K) 返回键K所指向的值V
Map map=new HashMap();
map.get(K);

★方法remove(K) 移除键K所指向的值V，并返回值V

★方法keySet() 返回一个键K的集合
Map map=new HashMap();
Set set=map.keySet();

★方法entrySet
Map map=new HashMap();
Set> set=map.entrySet();
用迭代器
Iterator> it=set.iterator();
while(it.hasNext())
{
Map.Entry entry=it.next();
String key=entry.getKey();
Integer value=entry.getValue();
System.out.println(key+" “+value);
}
或用增强for循环
for(Map.Entry entry:set)
{
System.out.println(entry.getKey()+” "+entry.getValue);
}

★import static java.lang.System.out;
可以将System.out.println();
节省为out.println();

Arrays也一样
import static java.util.Arrays.sort;
可将Arrays.sort(数组名);
节省为sort(数组名);

格式为static…静态成员（如out、sort）

★可变参数的写法：参数类型…参数名
一个方法里只能有一个可变参数，并且可变参数只能位于最后一位
int fangfa(int a,int b,int…c)或int fangfa(int…c)

★Collections工具类（以下都为静态方法）
Collections.sort(集合名); 从小到大排序
Collections.binarySearch(集合名，索引); 返回集合该索引处的元素
Collections.shuffle(集合名); 对集合中元素进行随机排序

JDBC_1

JDBC(Java Data Base Connectivity) -->Java数据库连接,是由一组Java语言编写的类和接口组成的Java API
步骤：1、注册驱动（告诉JVM用的是哪一个数据库的驱动）
2、建立连接（使用JDBC中的类，完成对MySQL数据库的连接）
3、获得语句执行平台（通过连接对象获取对SQL语句的执行者对象）
4、执行sql语句（使用执行者对象向数据库执行SQL语句）
5、处理结果
6、释放资源

★通过配置文件连接数据库
InputStream in =PropertiesDemo.class.getClassLoader().getResourceAsStream(“配置文件名”);//使用类的加载器

JDBC_2

JDBC工具类
★QueryRunner类的方法
update（Connection con，String sql，Object…param），返回值类型为int，代表执行SQL语句的条数
插入，修改，删除都可以通过此方法执行

---

query（Connection con，String sql，ResultSetHandler r）
或
query（Connection con，String sql，ResultSetHandler r，Object…param）
查询用此方法

query方法相关操作举例和一些相关的类：
1、ArrayHandler
将结果集的第一行储存到对象数组当中
Object[] 数组名 = QueryRunner类对象.query(con,sql,new ArrayHandler());
for(Object o:数组名)
{
System.out.println(o);
}

2、ArrayListHandler
将结果集的每一行封装到对象数组当中（产生很多数组），并且把对象数组存储到List集合
List 集合名 = QueryRunner类对象.query(con,sql,new ArrayListHandler());
for(Object[] o1:集合名)
{
for(Object o2:o1)
{
System.out.print(o+" ");
}
System.out.println();
}

3、ColumnListHandler
把结果集指定列的数据存储到List集合
List list = QueryRunner类对象.query(con,sql,new ColumnListHandler(“列名”));
for(Object o:list)
{
System.out.println(o);
}

4、MapListHandler
把结果集每一行存储到Map集合中，再把Map集合存储到List集合，用此类可以把列名显示出来
List> list = QueryRunner类对象.query(con,sql,new MapListHandler());
for(Map map:list)
{
for(String key:map.keySet())
{
System.out.print(key+" “+map.get(key)+” ");
}
System.out.println();
}

Thread多线程_1

★静态方法static Thread currentThread() 返回正在执行的线程对象
Thread t=Thread.currentThread();
System.out.println(t.getName());
以上代码为获取当前线程名字

★实现线程的三种方式：继承Thread类、实现Runnable接口、实现Callable接口（在视频22-23处）

★线程池：可以反复使用线程
ExecutorService es=Executors.newFixedThreadPool(10);数字代表线程池中储存的线程个数
es.submit(new XiaoSanRunnable());submit方法里传的参数为Runnable接口实现类的对象

es.shutdown();销毁线程池，一般不使用

Thread多线程_2

★同步代码块解决线程安全问题
格式:
synchronized(任意对象)
{
内容为线程要操作的共享数据
}

★同步方法格式：
public synchronized void() //方法的返回值类型与是否静态，可以修改
{
方法体
}

★比同步代码块更实用的Lock接口
格式：
private Lock lock=new ReentrantLock();private关键字声明看情况使用
public void run()
{
lock.lock();//启用锁
代码块
lock.unlock();//关闭锁
}

★notify（）
Object类的方法wait()

IO流_1

★File file=new File(“d:\heihei”);
file.createNewFile();创建文件的方法，返回值类型为boolean

★File file=new File(“d:\heihei”);
file.mkdir();创建文件夹的方法，返回值类型为boolean
注：创建多级文件夹的方法名为mkdirs，并且可以创建单个文件夹，所以推荐使用mkdirs方法

★File file=new File(“d:\heihei”);
boolean b=file.delete();删除文件或单个文件夹的方法，返回值类型为boolean
System.out.println(b);删除成功返回true，删除失败返回false
注：删除之后不会进入回收站，而是直接从硬盘删除，所以要谨慎使用！！！！

★File file=new File(“d:\heihei”);
boolean b=file.exists();判断路径是否存在的方法，返回值类型为boolean

★File file=new File(“d:\heihei”);
boolean b=file.isDirectory();判断封装路径是否为文件夹，是返回true，否返回false

★File file=new File(“d:\heihei”);
String[] s=file.list();获取封装路径（heihei）中的文件名和文件夹名的方法，返回值类型为String类型数组
for(String str:s)
{
System.out.println(str);
}

★File file=new File(“d:\heihei”);
File[] f=file.listFiles();获取封装路径（heihei）中的文件名和文件夹名的方法，返回值类型为File类型数组
for(File fi:f)
{
System.out.println(fi);
}

IO流_2

★OutputStream类（字节输出流）中的方法
write(byte b)
write(byte[] b)
write(byte[] b,int a,int c) “a”表示从数组索引a处开始，“c”表示写入的个数
一个write()方法写入一个字节
close() 释放对象//读写完成后别忘了释放！！！！！

★FileOutputStream（OutputStream的子类）
FileOutputStream fos=new FileOutputStream(“D:\d.txt”);重复创建会覆盖!
fos.write(“hello”.getBytes());getBytes()方法是将String类型数据转换成字节型数据
fos.close();

File file=new File(“D:\d.txt”);
FileOutputStream fos=new FileOutputStream(file,true);true表示在这个文件后面续写

fos.write(“hello”+"\r\n".getBytes());"\r\n"代表换行

★InputStream类（字节输入流）中的方法
read() 读取一个字节，返回整型数据
read(byte[] b) 读取字节，存入数组

★FileInputStream fis=new FilInputStream(“D:\d.txt”);假设d里面写的是"d"
int i=fis.read();
System.out.println((char)i);(char)表示强转

★FileWriter(字符输出流Writer的子类)
跟字节输出流中的方法相似
不过在write和close方法中间要多加一个flash方法

★FileReader(字符输入流Reader的子类)

IO流_3

★转换流
OutputStreamWriter 字符转向字节
InputStreamReader 字节转向字符

★BufferedOutputStream(字节缓冲输出流) -->不需要每次从底层调用文件,效率快，推荐使用
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(“D:\a.txt”));把要缓冲的对象传进去

BufferedInputStream(字节缓冲输入流)同上

★BufferedWriter(字符缓冲输出流)
该类特有的方法:void newLine();换行

BufferedReader(字符缓冲输入流)
BufferedReader br=new BufferedReader(new FileReader(“D:\a.txt”));
String s=br.readLine();方法readLine()表示读取一行的内容,如果到了末尾则返回null
System.out.println(s);
br.close();

IO流_4

Properties(Hashtable类的子类,可以使用Map里面的方法，但有隐患)
Properties没有泛型，键值对都是字符串
作用：将键值对以流的形式存入文件，以及存入之后再读取

★setProperty(String key,String value) 相当于Map里面的put方法：创建
getProperty(String key) 相当于Map里面的get方法：获取键key所对的值value

★load(InputStream in)或load(Reader r)传递字节或字符输入流的方法
Properties pro=new Properties();
FileReader fr=new FileReader(“D:\a.txt”);
pro.load(fr);
传入的文件有格式上的要求:txt类型，内容举个例子为name=xiaosan,在前面加#表示注释

★store(OutputStream out)或store(Writer w)传递字节或字符输出流的方法
store(OutputStream out,String comments)comments表示注释，不建议写中文注释
Properties pro=new Properties();
pro.setProperty(“name”,“xiaosan”);
pro.setProperty(“age”,“20”);
FileWriter fw=new FileWriter(“D:\a.txt”);
pro.store(fw,“I like”);
fw.close();

★对象的序列化：将对象中的数据以流的形式写入到文件中保存
对象的反序列化:将文件中的对象数据以流的形式读取出来

ObjectOutputStream(序列化流)
FileOutputStream fos=new FileOutputStream(“D:\a.txt”);
ObjectOutputStream oos=new ObjectOutputStream(fos);
Person p=new Person(“xiaosan”,20);
oos.writeObject§;
oos.close();
Person类需要实现Serializable接口，否则无法序列化！！！！！

ObjectInputStream(反序列化流)
FileInputStream fis=new FileInputStream(“D:\a.txt”);
ObjectInputStream ois=new ObjectInputStream(fis);
ois.readObject§;此方法会抛"类找不到"的异常
ois.close();

★静态不能序列化

★private transient int age;
transient关键字的作用：阻止成员变量序列化

★private static final long serialVersionUID=42123124343L;
为class文件指定序列号，即使修改了代码，也保持自己指定的序列号不变
static到UID之间的内容为固定的，不能修改

★PrintWriter(打印流，PrintStream也是打印流，不过PrintWriter更常用)
打印输出目的是File对象(OutputStream和FileWriter对象也是下面格式)：
File file=new File(“D:\a.txt”);
PrintWriter pw=new PrintWriter(fw);
pw.println(100);
pw.close();文件中写的是100

打印输出对象是char数组：
char[] c={‘a’,‘b’,‘c’};
System.out.println©;可直接打印出内容abc，而不是地址值

正则表达式

★正则表达式(以下出现的方法均为String类里的)
String s=“字符串”;
s.matches(“规则”);
s.split(“x”);按x切割
s.replaceAll(“规则”,“替换内容”);
matches()方法为boolean类型，如果匹配成功则返回true

规则：
例:1[123][0-9]{4,9}
第一位只能为1，第二位为1,2,3中任意一个就行，第三位为0-9中任意一个就行，{4,9}表示后面长度最少4个最多9个

 x: 代表的就是x
 \\: 代表"\" 
 \t: 制表符
 \n: 换行符
 \r: 回车符
 [abc]: 匹配a,b,c中任何一个
 [^abc]: 除了a,b,c
 [a-zA-Z] :匹配a-z或A-Z中任意字母
 [0-9]或[\d] :匹配0-9中任意数字
 [a-zA-Z_0-9]或[\w] :匹配a-z或A-Z中任意字母或下划线"_"或0-9中任意数字
 [.] :任意字符
 x? :x出现零次或一次
 x* :x出现零次或多次
 x+ :x出现一次或多次
 x{n} :x恰好出现n次
 x{n,} :x至少出现n次
 x{n,m} :x至少出现n次，但不超过m次
 !!!!使用[\d]或[\w]时，注意转义符，即[\\d]或[\\w]

练习:
“[a-zA-Z0-9_]+@[0-9a-z]+(\.[a-z]+)+” 邮箱命名规则

协议

★目前应用最广泛的网络通信协议是TCP/IP协议
其结构为：应用层（主要负责应用程序的协议，HTTP、FTP等协议）
传输层（主要使网络程序进行通信，可以采用TCP协议或UDP协议）
网络层
链路层（定义物理传输通道）

★IP地址和端口号

★UDP协议：通信之间无需网络连接
TCP协议：通信之间需要网络连接

★Socket类的构造方法Socket(String host,int port) 传递IP和端口号