学习JAVA已经有几年时间了，此中的乐趣可以用痛并快乐着来形容；痛，是因为学习过程很痛苦，快乐，是因为，成功运行的结果让我很快乐！！
下面对JAVASE学习的一些个人心得和经验之谈：
咱们先从环境的搭建开始吧：
第一篇：环境搭建
（一）JDK 的下载与安装
1、下载 JDK
在浏览器中输入 http://www.oracle.com/，可看到oracle 公司网站页面。在页面“Downloads”栏中可看到最新版的 JDK 软件包超链接。单击页面中“JDK”列对应的“DOWNLOAD”超链接，同意 Sun 公司的协议，可进入到下载页面。
2、安装 JDK
运行下载的软件包，可安装 JDK，在安装过程中可以设置安装路径及选择组件。
3、JDK 中的主要文件夹和文件
安装成功后，查看目录结构。
其中，bin 文件夹中包含编译器（javac.exe）、解释器（java.exe）、Applet 查看器（appletviewer.exe） 等可执行文件。lib 文件夹中包含一些系统的包，其中含有一些用于程序开发的类。
（二）设置环境变量
JDK的安装
1、设置 Windows 环境变量
在桌面“我的电脑”图标上单击右键，选择“属性”菜单， 将出现系统特性设置界面。在“高级”选项卡中单击“环境变量”按钮。将出现“环境变量”设置界面。在“系统变量”框中选择“Path”，然后单击“编辑”按钮，在出现的“编辑系统变量”对话框中， 在“变量值”栏的命令前添加“C:\Program Files\Java\jdk1.7.0\bin;”。
用同样方法设置环境变量“classpath”，其值为“.;C:\Program Files\Java\jdk1.7.0\lib;”。 设置完成后，单击“开始”→“所有程序”→“附件”→“命令提示符”打开 DOS窗口，在命令提示符下输入“java”或“javac”，回车后，如果出现其用法参数提示信息，则设置正确。
2、设置 DOS 起始位置
第一步：首先建立一个存放Java 源程序的路径和文件夹，如将实验中建立的 java 源程序都存放在为“f:\java”文件夹中。
第二步：单击“开始”→“所有程序”→“附件”→“命令提示符”，选择“命令提示符”选项右击， 在出现的下拉菜单中选择“属性”菜单，将打开“命令提示符 属性”对话框。
第三步：在“命令提示符 属性”对话框中选择“快捷方式”选项，在“起始位置”栏输入“f:\java”，单击“确定”按钮。
设置完成后，自开始菜单启动的DOS窗口将默认f:\java为当前目录。
（三）Eclipse的安装和配置（网上很多教程就不多说了）
（四）简单程序设计
1、编写一个简单的 Java Application程序，在屏幕上输出“I LIKE CSDN！”。
提示：
（1） 利用记事本写程序，保存在f:\java，命名为Aa.java文件。
（2） 编译程序：javac 源文件名
（3） 运行程序：java 类名（无扩展名）
2、用Applet小程序（在网页中运行）实现上面的小程序
提示：
（1）将源文件命名为 Bb.java存放到f:\java;
（2）编译源文件;
（3）编写一个html文件 Bb.html;
（4）在dos界面中输入appletviewer Bb.html运行；或者用浏览器打开Bb.html。
源文件Bb.java：
import java.awt.*; //导入java.awt包中的类
import java.applet.*; //导入java.applet包中的类
public class Bb extends Applet //继承Applet
{
public void paint(Graphics g) //重写paint方法
{
g.drawString("I LIKE CSDN!", 50, 60 ); //在(50,60)位置输出字符串
}
}
嵌入字节码文件的HTML文件Bb.html：
<HTML>
<APPLET code= "Bb.class" width= "500" height= "300">
</APPLET>
</HTML>
第二篇：JAVA基础
（一）基本数据类型
（二）特殊字符
（三）控制结构
常用：if, switch, for, while, and do while 结构语句；
特别理解continue和break的用法，break是跳出整个循环，continue是结束本次循环，继续下次循环。
从理论上来讲，所有程序都可以表示为三种结构:
顺序结构
选择结构
循环结构
选择结构表达式：
if-else语句（2种形式）
if(布尔表达式)
语句1；
if(布尔表达式)
语句1；
else
语句2；
if(布尔表达式)
语句1；
if(布尔表达式)
语句1；
else
语句2；
三种循环语句：
While循环 （先判断，后执行）
While循环 （先判断，后执行）
while(布尔表达式)
循环体；
do-while循环（先执行，后判断）
do
循环体；
while(布尔表达式);
For循环（格式简洁，变量变化点明确）
for(初值; 布尔表达式; 步长值)
循环体；
（四）类和对象
修饰符
继承性
一个类能继承另一个类的所有属性和行为的机制。
格式：
class 子类名称 [extends 父类名称]
{ }
注意事项:
如果[extends 父类名称] 不存在，则子类继承自Object类,即所有类直接或间接继承自Object类。
格式：
class 子类名称 [extends 父类名称]
{ }
注意事项:
如果[extends 父类名称] 不存在，则子类继承自Object类,即所有类直接或间接继承自Object类。
覆盖和重载的区别：
方法覆盖和方法重载是类的多态性的两种表现。
方法覆盖
子类的成员方法与父类的成员方法具有相同的头部（名称和参数）。
父类中的方法不能是private类型的。
覆盖的方法的访问权限必须大于等于被覆盖方法的访问权限。例如：被覆盖方法的访问权限是“friendly”，那么覆盖的方法的访问权限可以是“friendly”、protected、public。
方法重载
在同一个类中，具有多个同名但不同参数的方法。
方法覆盖
子类的成员方法与父类的成员方法具有相同的头部（名称和参数）。
父类中的方法不能是private类型的。
覆盖的方法的访问权限必须大于等于被覆盖方法的访问权限。例如：被覆盖方法的访问权限是“friendly”，那么覆盖的方法的访问权限可以是“friendly”、protected、public。
方法重载
在同一个类中，具有多个同名但不同参数的方法。
注意：声明为static的 方法不能被覆盖。
被final 修饰的方法不能被覆盖。
被final 修饰的方法不能被覆盖。
super是用在子类和父类之间，this是用在本类的构造函数间
抽象类
格式：
abstract class 类名
{ …
abstract 返回值类型 方法名（参数列表）；
…
}
{ …
abstract 返回值类型 方法名（参数列表）；
…
}
注意事项：
抽象方法无方法体。
抽象方法必须置于抽象类中
抽象方法无方法体。
抽象方法必须置于抽象类中
接口
格式
[public] interface 接口名[extends 父接口名列表]
{
[public][static][final] 变量名= 常量值； //常量声明
[public][abstract] 返回值类型 方法名(参数列表)
//抽象方法声明
}
{
[public][static][final] 变量名= 常量值； //常量声明
[public][abstract] 返回值类型 方法名(参数列表)
//抽象方法声明
}
注意事项
接口可实现类间多重继承。
接口是一组常量和抽象方法的集合。
接口里的常量默认是用public static final标识的 。
接口中的所有方法的修饰符都是 public abstract。
接口可实现类间多重继承。
接口是一组常量和抽象方法的集合。
接口里的常量默认是用public static final标识的 。
接口中的所有方法的修饰符都是 public abstract。
包
包是一组相关的类或接口的集合, 它提供了访问保护和名字空间管理。Java编译器使用文件系统目录来保存包。
程序员能将相互关联的类放在同一包中。
程序员能很方便地了解到在哪里可以找到能完成特定功能的类
由于每个包都创建了一个名字空间，个人创建的类名不会和其它包中的类名发生冲突
可以使同一包中的类彼此不加限制地访问，而同时对其它包中的类提供访问控制。
程序员能很方便地了解到在哪里可以找到能完成特定功能的类
由于每个包都创建了一个名字空间，个人创建的类名不会和其它包中的类名发生冲突
可以使同一包中的类彼此不加限制地访问，而同时对其它包中的类提供访问控制。
异常
异常处理：
异常处理的两种方法：捕捉异常和抛出异常。
自定义异常。
自定义异常。
当出现程序无法控制的外部环境问题(用户提供的文件不存在，文件内容损坏，网络不可用...)时，Java就会用异常对象来描述。
异常处理
异常处理是编写应用程序解决异常
注意事项：
有些异常非常隐蔽，在编译时不能发现。
一旦引发异常，程序将突然中止。
发生异常后此前分配的所有资源都将保留在相同的状态，这将导致资源漏洞。
异常体系结构
补充说明
Error
不能由应用程序直接处理，必须交由操作系统处理。很少发生，但是一旦发生，通常是致命的
Exception
RuntimeException(运行时异常)
RuntimeException的子类异常。Java编译器允许程序不对它们做出处理。(包含大多数常见异常，如：0做除数，无效数组索引等)
Other Exception(非运行时异常)
除了运行时异常之外的其他由Exception继承来的异常类。Java编译器要求程序必须捕获或声明这种异常，否则编译就报错。(比如：数据库的操作可能导致的异常)
Exception
RuntimeException(运行时异常)
RuntimeException的子类异常。Java编译器允许程序不对它们做出处理。(包含大多数常见异常，如：0做除数，无效数组索引等)
Other Exception(非运行时异常)
除了运行时异常之外的其他由Exception继承来的异常类。Java编译器要求程序必须捕获或声明这种异常，否则编译就报错。(比如：数据库的操作可能导致的异常)
异常的处理方法：
1、处理异常--try/catch/finally
一旦捕获异常，马上进行处理：
在方法中使用try/catch/finally语句自己处理异常。
一旦捕获异常，马上进行处理：
在方法中使用try/catch/finally语句自己处理异常。
格式：
try {
. . . // 可能会发生异常的程序块
}
catch (异常类名1 异常对象1)
{
. . . // 处理类型1的异常
}
catch (异常类名2 异常对象2)
{
. . . // 处理类型2的异常
}
try {
. . . // 可能会发生异常的程序块
}
catch (异常类名1 异常对象1)
{
. . . // 处理类型1的异常
}
catch (异常类名2 异常对象2)
{
. . . // 处理类型2的异常
}
2、抛出异常--throws
捕获异常，但并不处理，交由调用方处理，即
将异常的处理递交给当前方法的调用者去处理，称为抛出异常。
throws就是放在类与方法后面, 要调用这个类与方法时,直接将类或方法抛出异常，交给调用者处理。
throw关键字通常用在方法体中，并且抛出一个异常对象
throw关键字通常用在方法体中，并且抛出一个异常对象
第三篇：IO流
IO流体系
键盘输入和屏幕输出；
File类对文件和文件夹的管；
使用FileInputStream 和 FileOutputStream 类读写二进制文件；
使用 FileReader 和 FileWriter 类读写文本文件。
输入/输出流可以从以下几个方面进行分类：
从流的方向划分
输入流
输出流
从流的内容划分
面向字节的流
面向字符的流
java.io包的顶层结构
流的操作规律
之所以要弄清楚这规律是因为流对象太多，开发时不知道用哪个对象合适。 想要知道对象开发时用到哪些对象，只要通过四个明确即可。 1.明确源和目的（汇） 源：inputstream reader 目的：outputstream writer 2.明确数据是否是纯文本的数据。 源：如果是纯文本，reader 如果不是：inputstream 目的：如果是纯文本，writer 如果不是：outputstream 到这里就可以明确需求中具体要使用哪个体系。 3.明确具体的设备。 源设备：硬盘：file ，键盘：system.in 内存:数组 网络：socket流 目的设备：硬盘：file 控制台：system.out 内存：数组 网络：socket流 4.是否需要其他额外功能 ①是否需要高效（缓冲区）：是，要加上buffer 例如： 需求1：复制一个文本文件 ①明确源和目的；源：inputstream reader。目的：outputstream writer ②是否是纯文本？是！源：reader。目的：writer ③明确具体设备：源：硬盘：file。目的：硬盘，file filereader fr=new filereader("a.txt"); filewriter fw=new filewriter("b.txt"); ④需要额外功能吗？需要：需要高效。。。 bufferedreader bufr=new bufferedreader(new filereader("a.txxt")); bufferedwriter bufw=new bufferedwriter(new filewriter("b.txt"));
需求2：读取键盘录入信息，并写入到一个文件中
①明确源和目的；源：inputstream reader。目的：outputstream writer
②是否是纯文本？是！源：reader。目的：writer
③明确具体设备：源：键盘：system.in。目的：硬盘，file
inputstream in=system.in;
filewriter fw=new filewriter("b.txt");
④需要额外功能？
需要：转换。将字节流转成字符流，因为明确的源是reader，这样操作文本数据更便捷，所以要将已有的字节流转成字符流
使用字节--》字符。inputstreamreader
inputstreamreader isr=new inputstreamreader（system.in）；
filewriter fw=newfilewriter（"b.txt"）；
还需要高效
bufferreader bufr=new bufferedreader（new inputstreamreader（system.in））；
bufferedwriter bufw=new bufferedwriter（new filewriter（"b.txt"））；
需求三：将一个文本文件数据显示在控制台上
1.明确源和目的。源：inputstream reader；目的：outputstream writer
2.是否是纯文本？是：源，reader；目的writer
3，明确具体设备。源：硬盘：file；目的：控制台：system.in
filereader fr=new filereader("a.txt");
outputstream out =system.out;
4.需要额外功能吗？
需要：转换。
filereader fr=new filereader（"a.txt"）；
outputstreamwriter osw=new outputstreamwriter(system.out);
还需要高效
bufferedreader bufr=new bufferedreader(new filereader("a.txt"));
bufferedwriter bufw=new bufferedwriter(new outputstreamwriter(system.out));
需求四：读取键盘录入数据，显示在控制台上
1.明确源和目的。源：inputstream reader；目的：outputstream writer
2.是否是纯文本？否！源：inputstream ；目的：outputstream
3.明确设备。源：键盘 system.in ;目的：控制台：system.out
inputstream isr=system.in;
outputstream osr=system.out;
4.是否需要额外功能？
需要转换：因为都是字节流，但是操作的却是文本数据，所以使用字符流操作更为便捷
inputstreamreader isr=new inputstreamreader(system.in);
outputstreamwriter osr=new inputstreamwriter(system.out);
需要高效
bufferedreader bufr=new bufferedreader(new inputstreamreader(system.in));
bufferedwriter bufw=new bufferedwriter(new outputstreamreader(system.out));
=================================
需求⑤：将一个中文字符串数据安装指导的编码表写入到一个文本文件中
1.目的：outputstream writer
2.是纯文本：writer
3.设备：硬盘file
filewriter fw=new filewriter("a.txt");
fw.wrrter("你好");
注意：既然需求中已经明确了指定编码表的动作，那就不可以使用filewriter，因为
filewriter内部是使用默认的本地码表。只能使用其父类outputstreamwriter
outputstreamwriter 接收一个字节输出流对象，既然是操作文件，那么该对象是fileoutputstream
outputstreamwriter osw=new outputstreamwriter(new fileoutputstream("a.txt"),charsetname);
需要高效吗？
bufferedwriter bufw=new bufferedwriter(new outputstreamwriter(new outputstream("a.txt"),"utf-8"));
什么时候使用转换流拟？
1.源或者目的的对应设备是字节流，但是操作的却是文本数据，可以使用转换流作为桥梁，提高对文本操作的便捷。
2.一旦操作文本涉及到具体的编码表时，必须使用转换流
实例：
<span style="font-size:14px;">public class Copydemo { /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub /* * 复制原理：连读带写 * 读取c盘文件中的数据写入到d盘 * * */ //copybybite(); copybyarray(); } public static void copybyarray() { // TODO Auto-generated method stub FileReader fr1=null; FileWriter fw1=null; try { fr1=new FileReader("E:\\1.txt"); fw1=new FileWriter("e:\\3.txt"); //创建一个临时容器，用于缓存读取到的字符 char[] buf=new char[1024]; //定义一个变量记录读取到的字符数 int len=0; while((len=fr1.read(buf))!=-1){ System.out.println(); fw1.write(buf,0,len); } } catch (Exception e) { // TODO: handle exception } finally{ if(fw1!=null) try { fw1.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } if(fr1!=null) try { fr1.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } public static void copybybite() throws FileNotFoundException, IOException { //1.读取一个已有文件 FileReader fr=new FileReader("E:\\1.txt"); //2.创建一个目的，用于存储读取到的文件 FileWriter fw=new FileWriter("E:\\2.txt"); //3.频繁的读写文件 int ch=0; while((ch=fr.read())!=-1){ fw.write(ch); } //4.关闭文件 fr.close(); fw.close(); } } ② public class FileReaderdemo { /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub //1.创建读取字符数据的流对象 //在差U给你叫读取流对象时，必须要明确呗读取的文件，一定要存在 //用一个读取流关联一个已经存在文件 //demo_1(); //使用read(char[])读取文本文件数据。先创建字符数组 FileReader fr1=new FileReader("E:\\1.txt"); char[] buf=new char[1024]; int num=0; while((num=fr1.read(buf))!=-1){ System.out.println(new String(buf)); } } public static void demo_1() throws FileNotFoundException, IOException { FileReader fr=new FileReader("demo.txt"); int ch = fr.read(); System.out.println(ch); fr.close(); } } ③ public class Filewriterdemo { //System.getProperty("line.separator");调用系统回车换行符 private static final String LINE_SEPERATOR = System.getProperty("line.separator"); /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub //创建一个可以往文件中写入字符数据的字符输出对象 /* * * 如果构造函数中加入true，可以继续写入 * */ FileWriter fw=new FileWriter("demo.txt",true); //数据写入到临时存储缓冲区中 fw.write("abc"+LINE_SEPERATOR+"ESF"); fw.write("xixi"); //进行刷新，将数据写入到目的地中 //fw.flush(); //关闭资源、流，并在关闭之前调用flush刷新流 fw.close(); } } ④ public class IOExceptionFilewriterdemo { //System.getProperty("line.separator");调用系统回车换行符 private static final String LINE_SEPERATOR = System.getProperty("line.separator"); /** * @param args * @throws IOException */ public static void main(String[] args) { // TODO Auto-generated method stub FileWriter fw=null; try { fw = new FileWriter("demo.txt"); fw.write("abc"+LINE_SEPERATOR+"ESF"); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } //数据写入到临时存储缓冲区中 finally{ try { if(fw!=null)//一定要先判断打开的文件是否为空 fw.close(); } catch (IOException e) { // TODO Auto-generated catch block throw new RuntimeException("关闭失败"); } } } } ⑤ public class readkey { /** * 键盘输入数据 * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub read_key(); } public static void read_key() throws IOException { // TODO Auto-generated method stub InputStream in=System.in; /* * 获取用户键盘输入的数据并将数据编程大写显示在控制台上 * 输入over则结束 * 思路： * 1.因为键盘录入只读取一个字节，要判断是否是over * 需要将读取到的字节拼成字符串 * 2.需要一个容器：stringbuilder * 3.在用户存储之前将录入的数据编程字符串 * * */ //1.创建容器 StringBuilder sb=new StringBuilder(); //2.获取键盘读取流 InputStream inputStream=System.in; //3.定义变量记录读取到的字节，并循环获取 int ch=0; while((ch=inputStream.read())!=-1){ //在存储之前要判断是否是换行标记，因为换行标记不存储 if(ch=='\r') continue; if(ch=='\n'){ String temp=sb.toString(); if("over".equals(temp)) break; System.out.println(temp.toUpperCase()); sb.delete(0, sb.length()); }else //将读取到的字节存储到stringbuilder中 sb.append((char)ch); // System.out.println(sb); } } } ⑥ public class filedemo2 { /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub /* * file对象的常见方法 * * 1.获取：①获取文件名称②获取文件路径；③获取文件大小④获取文件修改时间 * 2.创建与删除：①boolean * 3.判断： * * * */ getdemo();//获取功能 createanddeletedemo();//创建与删除 isdemo();//判断 rename();//重命名 information(); listroot(); } public static void listroot() { // TODO Auto-generated method stub File[] files=File.listRoots(); for(File file : files){ System.out.println(file); } } public static void information() { // TODO Auto-generated method stub File file=new File("e:\\"); System.out.println(file.getFreeSpace()); System.out.println(file.getTotalSpace()); System.out.println(file.getUsableSpace()); } public static void rename() {//重命名 // TODO Auto-generated method stub File f1=new File("e:\\1.txt"); File f2=new File("e:\\w.txt"); boolean b=f1.renameTo(f2); System.out.println("b="+b); } public static void isdemo() { // TODO Auto-generated method stub File f=new File("e:\\1.txt"); boolean r=f.isFile(); boolean w=f.exists(); } public static void createanddeletedemo() throws IOException { // TODO Auto-generated method stub File file=new File("e:\\1.txt"); //和输出流不一样，如果文件不存在，则创建，如果存在，则不创建 boolean b=file.createNewFile(); System.out.println(b); //文件的删除 boolean d=file.delete(); System.out.println(d); //创建目录 File dir=new File("abc"); boolean i=file.mkdir();//i=file.mkdirs();创建多级目录 System.out.println(i); } public static void getdemo(){ File file=new File("E:\\1.txt"); String name=file.getName();// String abspath=file.getAbsolutePath();//获取绝对路径 String path=file.getPath(); long len=file.length(); long time=file.lastModified();//最后一次修改时间 Date date=new Date(time); DateFormat dateFormat=DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG); String str_time=dateFormat.format(date); System.out.println("name: "+name); System.out.println(abspath); System.out.println(path); System.out.println(str_time); System.out.println(date); System.out.println(len); } } ⑦ public class FileDeletdemo { /** * 删除目录 * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub File dir=new File("e:\\demo"); deleteall(dir); } public static void deleteall(File dir) { // TODO Auto-generated method stub File[] files =dir.listFiles(); for(File file : files){ if(file.isDirectory()){ deleteall(file); } else { file.delete(); } } System.out.println("dir:"+dir.delete()); } } ⑧ package filetestdemo; import java.io.File; public class FileTest1 { /** * 获取指定目录下的当前的所有文件夹或者文件对象 * 深度遍历 * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub File dir=new File("e:\\红客"); listall(dir,0); } public static void listall(File dir,int level) { // TODO Auto-generated method stub System.out.println(getspace(level)+dir.getName()); // System.out.println("dir:"+dir.getAbsolutePath()); level++; File[] files=dir.listFiles(); for (int i = 0; i < files.length; i++) { if(files[i].isDirectory()){ listall(files[i],level); } else { System.out.println(getspace(level)+files[i].getName()); } } } public static String getspace(int level) { // TODO Auto-generated method stub StringBuilder sbr=new StringBuilder(); sbr.append("|--"); for(int i=0;i<level;i++){ sbr.insert(0, "| "); } return sbr.toString(); } }</span>第四篇：线程线程生命周期的五大状态
生命周期各阶段对应执行的方法
① 新生状态
Thread thread1= new Thread( );
② 就绪状态
thread1. start( ) ;
③ 运行状态
run( );
注意：run( )方法无需调用，将在就绪态后自动执行
④ 阻塞状态
thread1. sleep (long millis);
public static void sleep(long millis) 会抛出中断异常；
InterruptedException 必须被捕捉。
thread1. wait();
⑤ 终止/死亡状态
thread1. stop();
thread1.destroy();
继承thread类的特点：
创建一个类继承Thread类； 重写Thread类的run()方法，在此方法中填写要在这个线程中要执行的代码； 用关键字new创建所定义的线程类的一个对象； 调用该线程对象的start()方法启动线程。 优点：简单明了，符合思维习惯。 缺点：若类存在父类，则无法再继承Thread类。
实例：
<span style="font-size:14px;">class ThreadDemo1 extends Thread{ String city; int total; ThreadDemo1(String x){ total=0; city=x;} //线程运行状态 public void run(){ for(int i=0;i<5;i++){ int time=((int)(1000*Math.random())); total+=time; System.out.println(city); } } public static void main(String args[]) throws InterruptedException { System.out.println("去那旅游好呢？程序决定吧！"); //创建新生状态 ThreadDemo1 threadA=new ThreadDemo1("广州 "); ThreadDemo1 threadB=new ThreadDemo1("杭州 "); //线程就绪状态 threadA.start(); threadB.start(); threadA.join(); threadB.join(); if(threadA.total>threadB.total) System.out.println("去广州"); else{ System.out.println("去杭州"); } } }</span>
实现runnable接口的特点：
自定义类实现Runnable接口；
定义方法run()；
用关键字new创建所定义的线程类的一个对象；
以此对象为参数，使用Thread类的构造方法创建线程对象；
使用start()启动线程。
优点：解决了多继承的问题
缺点：Runnable接口并没有任何对线程的支持，我们还必须创建Thread类的实例
实例：
<span style="font-size:14px;">public class ThreadDemo2 implements Runnable{ private String city; private int total; public ThreadDemo2(String city) { super(); total=0; this.city = city; } public static void main(String[] args) throws InterruptedException { // TODO Auto-generated method stub System.out.println("去哪裡旅遊嘞？讓程序覺得吧"); ThreadDemo2 t1= new ThreadDemo2("廣州"); ThreadDemo2 t2=new ThreadDemo2("上海"); Thread thread1=new Thread(t1); Thread thread2=new Thread(t2); thread1.start(); thread2.start(); thread1.join(); thread2.join(); if(t1.total<t2.total){ System.out.println("去廣州"); } else System.out.println("去上海"); } @Override public void run() { // TODO Auto-generated method stub for(int i=0;i<5;i++){ int time=(int)(Math.random()*1000); total=total+time; System.out.println(city); } } }</span><span style="font-size:24px; "> </span>
第五篇：JDBC技术1、数据库存取原理
Java代码调用 JDBC类库
JDBC 加载驱动
Driver 与特定数据库交互
JDBC
Java数据库连接（Java Database Connectivity）
支持数据库存取的技术
包
在JDBC中包括了两个包：java.sql和javax.sql。
① java.sql 基本功能。这个包中的类和接口主要针对基本的数据库编程服务，如生成连接、执行语句以及准备语句和运行批处理查询等。同时也有一些高级的处理，比如批处理更新、事务隔离和可滚动结果集等。
② javax.sql 扩展功能。它主要为数据库方面的高级操作提供了接口和类。如为连接管理、分布式事务和旧有的连接提供了更好的抽象，它引入了容器管理的连接池、分布式事务和行集（RowSet）等。
java.sql.Connection
与特定数据库的连接（会话）。能够通过getMetaData方法获得数据库提供的信息、所支持的SQL语法、存储过程和此连接的功能等信息。代表了数据库。
java.sql.Driver
每个驱动程序类必需实现的接口，同时，每个数据库驱动程序都应该提供一个实现Driver接口的类。
java.sql.DriverManager
(Class) 管理一组JDBC驱动程序的基本服务。作为初始化的一部分，此接口会尝试加载在”jdbc.drivers”系统属性中引用的驱动程序。只是一个辅助类，是工具。
java.sql.Statement
用于执行静态SQL语句并返回其生成结果的对象。
java.sql.PreparedStatement
继承Statement接口，表示预编译的SQL语句的对象，SQL语句被预编译并且存储在PreparedStatement对象中。然后可以使用此对象高效地多次执行该语句。
java.sql.CallableStatement
用来访问数据库中的存储过程。它提供了一些方法来指定语句所使用的输入/输出参数。
java.sql.ResultSet
指的是查询返回的数据库结果集。
java.sql.ResultSetMetaData
可用于获取关于ResultSet对象中列的类型和属性信息的对象。
驱动程序的分类
驱动程序按照工作方式分为四类：
（1）JDBC-ODBC bridge + ODBC 驱动
JDBC-ODBC bridge桥驱动将JDBC调用翻译成ODBC调用，再由ODBC驱动翻译成访问数据库命令。
优点：可以利用现存的ODBC数据源来访问数据库。
缺点：从效率和安全性的角度来说的比较差。不适合用于实际项目。
（2）基于本地API的部分Java驱动
我们应用程序通过本地协议跟数据库打交道。然后将数据库执行的结果通过驱动程序中的Java部分返回给客户端程序。 4
优点：效率较高。
缺点：安全性较差。
（3）纯Java的网络驱动
（中间协议） （本地协议）
app JDBC 纯Java--------------中间服务器---------DB
缺点：两段通信，效率比较差
优点：安全信较好
（4）纯Java本地协议
通过本地协议用纯Java直接访问数据库。
特点：效率高，安全性好。
数据库操作步骤
JDBC中几个重要接口
第六篇：网络编程这部分内容我打算用几个实例来讲解：相信看完这四个实例，大家会对UDP和TCP传输有个大概的了解<span style="font-size:18px;">import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.Socket; import java.net.UnknownHostException; public class TransClient { /** * @param args * @throws IOException * @throws UnknownHostException */ public static void main(String[] args) throws UnknownHostException, IOException { //将数据传输到服务器端，然后转换成大写再传回给客户端 /* * 思路： * 客户端： * 1.需要先有socket端点 * 2.客户端的数据源，键盘 * 3.客户端的目的：socket * 4.接受服务端的数据，源socket * 5.将数据显示在控制台：目的：控制台 * 6.在这些源中操作数据，都是文本数据 * * 转换客户端： * 1.创建socket客户端对象， * 2，获取键盘录入 * 3.将录入的信息发送给socket输出 * * */ //1.创建socket客户端对象 Socket s=new Socket("192.168.174.1",10000); //2.获取键盘录入 BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in)); //3.socket输出流 PrintWriter out=new PrintWriter(s.getOutputStream(),true);//true自动刷新 //4.socket输入流，读取服务端返回的大写数据 BufferedReader burIN=new BufferedReader(new InputStreamReader(s.getInputStream())) ; String line=null; while((line=bufr.readLine())!=null){ if("over".equals(line)) break; //輸出到服務端 out.println(line); //读取服务端发回的一行大写数据 String upperString=burIN.readLine(); System.out.println(upperString); } s.close(); } } import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Socket; public class TransServer { /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub /* * 1.serversocket服务 * 2.获取socket对象 * 3.源：socket，读取客户端发送过来的需要转换的数据 * 4.目的，显示在控制台上 * 5.将数据转成大写发送给客户端 * */ ServerSocket ss=new ServerSocket(10000); //2.获取socket对象 Socket s=ss.accept(); //获取IP String ip=s.getInetAddress().getHostAddress(); System.out.println(ip); //3.获取socket读取流，并装饰 BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream())) ; //4.获取socket的输出流，并装饰 PrintWriter out=new PrintWriter(s.getOutputStream(),true); String line=null; while((line=bufIn.readLine())!=null){ System.out.println(line); out.println(line.toUpperCase()); } s.close(); ss.close(); } }</span>
<span style="font-size:18px;">import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.SocketException; import java.net.UnknownHostException; public class UDPsenddemo { /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub /* * UDP发送端思路： * 1.建立socket连接datagramsocket * 2.将数据封装到数据包中datagrampacket * 3.通过send方法将数据传输 * 4。关闭 * */ //1.建立连接 DatagramSocket socket=new DatagramSocket(); //输入要传输的数据 String string="今天天气不错"; //封装成数组，因为socket中只能传输数组而不能传输字符串 byte[] but=string.getBytes(); //封装到数据包中 DatagramPacket dp=new DatagramPacket(but, but.length, InetAddress.getByName("127.0.0.1"), 10000); //3.通过socket的send传输数据包 socket.send(dp); //4.关闭socket socket.close(); } } //receiver import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.SocketException; public class UDPreceivedemo { /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub /* * 接受端思路： * 1.创建socket通信接口，因为是接受端，所以注意要明确端口 * 2.创建packet数据包存储接受到的数据 * 3.通过socket的receive方法接受数据 * 3.调用packet的接受方法分析数据 * 4.关闭资源 * */ //1.创建socket，明确端口：和发送端的接口相同 DatagramSocket socket=new DatagramSocket(10000); //2.创建数组，用于存储数据 byte[] but=new byte[1024]; DatagramPacket dp=new DatagramPacket(but, but.length); //3.调用receive接受数据 socket.receive(dp); //4.通过datagram解析数据 String ip=dp.getAddress().getHostAddress(); int port=dp.getPort(); String text=new String(dp.getData(),0,dp.getLength()); System.out.println(ip+port+text); socket.close(); } }</span>
<span style="font-size:18px;">package TCP; import java.io.IOException; import java.io.OutputStream; import java.net.Socket; import java.net.UnknownHostException; public class Client { /** * @param args * @throws IOException * @throws UnknownHostException */ public static void main(String[] args) throws UnknownHostException, IOException { // TODO Auto-generated method stub //客户端发生数据到服务端 /* * tcp传输，客户端建立的过程 * 1.创建tcp客户端socket服务，使用的是socket对象 * 建议该对象一创建就明确目的地，要链接的主机 * 2，如果链接建立成功，说明数据传输通道已建立 * 该通道就是hisocket流，是底层建立好的，既然是流，说明这里既有输入也有输出 * 想要输入或者输出流对象，可以找socket来获取 * 可以通过getoutputstream()和getinputstream()；来获取 * 3，使用输出流将数据写出 * 4.关闭资源 * * */ //一建立连接就明确目的地 Socket socket=new Socket("192.168.194.1",10000); //获取socket流中的输出流 OutputStream outputStream=socket.getOutputStream(); //使用输出流将指定的数据写出去 outputStream.write("你好".getBytes()); //关闭资源 socket.close(); } } //服务端 package TCP; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.net.ServerSocket; import java.net.Socket; public class ServerDemo { /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub //创建服务端对象 ServerSocket ss=new ServerSocket(10000); //链接客户端 Socket s=ss.accept(); //获取ip String ip=s.getInetAddress().getHostAddress(); //通过socket对象获取输入流，要读取客户端发来的数据 InputStream inputStream=s.getInputStream(); byte[] buf=new byte[1024]; int len=0; len=inputStream.read(buf); String text=new String(buf,0,len); System.out.println(ip+":"+text); ss.close(); s.close(); } }</span>
第七篇：API以及操作
集合的一些技巧
需要唯一吗？
需要：set
需要指定顺序吗？
需要：TreeSet
不需要：hashset
但是想要有个和存储一致的顺序（有序）：linkedhashset
不需要：List
需要频繁增删吗？
需要：linkedlist
不需要：arraylist
如何记录每一个容器的结构和所属体系？
看名字！
List
-arraylist
-linkedlist
set
--hashset
--treeset
后缀名就是该集合所属的体系，
前缀名就是该集合的数据结构。
看到array：就要想到数组和查询快，有角标。
看到link：就要想到链表，就要想到增删快，就要想到add get remove+first last 的方法
看到hash：就要想到哈希表，就要想到唯一性，就要想到元素需要覆盖hashcode方法和equals方法
看到tree：就要想到二叉树，就要想到排序，就要想到两个接口，comparable，comparator
而且同窗这些常用的集合容器都是不同步的。
泛型jdk1.5出现的安全机制
好处：
1，将运行时期的问题classcastexception转到了编译时期
2，避免了强制转换的麻烦
<>：什么时候用？当操作的引用数据类型不确定的时候，就使用<>.
将要操作的引用数据类型传入即可，其实<>就是一个用于接收具体引用数据类型的参数范围
在程序中，只要用到了带有<>的累或者接口，就要明确传入的具体引用数据类型
泛型技术是给编译器使用的技术，用于编译时期，确保了类型的安全
运行时，会将泛型去掉，生成的class文件中是不带泛型的，这个称为泛型的擦除
为什么擦除呢？因为为了兼容运行的类加载器
泛型的补偿：在运行时，通过获取元素的类型进行转换动作，不用使用者再强制转换了
泛型的通配符： ？ 未知类型
案例①import java.util.Iterator; import java.util.TreeSet; public class Genericdemo { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub TreeSet<Person> treeSet= new TreeSet<Person>(); treeSet.add(new Person("lisi1",10)); treeSet.add(new Person("lisi2",15)); treeSet.add(new Person("lisi3",2)); Iterator<Person> it=treeSet.iterator(); while(it.hasNext()){ Person p = it.next(); System.out.println(p.getAge()+"..."+p.getName()); } } } ② public class Jk { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub InterImpl interImpl = new InterImpl(); interImpl.show("abc"); InterImpl2<Integer> in2=new InterImpl2<Integer>(); in2.show(5); } } //泛型接口，讲泛型定义在接口上 interface Inter<T>{ public void show(T t); } class InterImpl implements Inter<String>{ public void show(String str){ System.out.println("show:::"+str); } } class InterImpl2<Q> implements Inter<Q>{ public void show(Q q){ System.out.println("show :"+ q); } } ③ public class Person implements Comparable<Person>{ private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Person() { super(); // TODO Auto-generated constructor stub } public Person(String name, int age) { super(); this.name = name; this.age = age; } @Override public int compareTo(Person p) { // TODO Auto-generated method stub /** * 下面的两行注释的代码是比较年龄 * */ // int temp=this.getAge()- p.getAge(); // return temp==0?this.getAge()-p.getAge():temp; /** * 比较姓名 * */ int temp=this.getName().compareTo(p.getName()); return temp==0?this.getAge()-p.getAge():temp; } } ④ import java.util.Comparator; public class comparabyname implements Comparator<Person> { @Override public int compare(Person arg0, Person arg1) { // TODO Auto-generated method stub int temp= arg0.getName().compareTo(arg1.getName()); return temp==0?arg0.getAge()-arg1.getAge():temp; } } 案例二： import java.util.ArrayList; import java.util.Iterator; public class Fxtonpeifu { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub ArrayList<String> a1= new ArrayList<String>(); a1.add("abc"); a1.add("efd"); ArrayList<Integer> a2=new ArrayList<Integer>(); a2.add(2); a2.add(4); Colle(a1); Colle(a2); } /** * 通配符：？ * 的使用：可以充当任何类型 * */ private static void Colle(ArrayList<?> a1) { Iterator<?> iterator=a1.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } } /** * 作用： * 对类型的限定 * 只能是Person类或者其子类 * ？extends E ：接受E类型，或者E的子类型对象，上限！ * ？ super E ：接受E类型或者E的父类型。下限！ * 一般在存储元素的时候都是用上限，因为这样取出都是按照上限类型来运算的 ， * 不会出现类型安全隐患 * * * 通常对集合的元素进行取出操作时，可以使用下限 * 存什么类型，可以用该类型的父类型接收 * */ /*/public static void printcollection(Collection<? extends Person> a1){ * * Iterator<? extends> iterator=a1.iterator(); while(iterator.hasNext()){ Person p = it.next(); System.out.println(p.getname()+p.getage()); } } */ }
mapmap：一次添加一对元素；collection一次添加一个元素
map也称为双列集合，collection集合称为单列集合
其实map集合中存储的就是键值对
map集合中必须保证键的唯一性
常用方法：
1：添加：value put(key,value):返回前一个和key关联的值，如果没有返回null交
3：判断：boolean containsKey(key)
boolean containsValue(key)
boolean isEmpty();
4：获取：
value get(key):通过键获取值，如果没有该键，返回null。
可以通过返回空来判断是否包含指定键
int size():获取键值的对数
map常用的子类：
hashtable：内部结构是哈希表，是同步的。不允许null作为键，null作为值
|-Properties：用来存储键值对型的配置文件信息，可以和Io技术结合
hashmap：内部结构是哈希表，不是同步的。允许null作为键，null作为值
treemap：内部结构是二叉树，不是同步的。可以对map集合中的键进行排序
注意：map没有迭代器，所以想取出map中的所以元素必须通过keyset方法获取map中所有的键所在的set集合，再通过set的迭代器获取到每一个键，再对每一个键通过map集合的get方法获取其对应的值即可
案例：①： import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class mapdemo { public static void main(String args[]){ Map<Integer ,String > map= new HashMap<Integer,String >(); //method_1(map); method3(map); } public static void method_1(Map<Integer,String> map){ //map没有迭代器，所以想取出map中的所有元素 //必须通过keyset方法获取map中所有的键所在的set集合， //再通过set的迭代器获取到每一个键，再对每一个键通过map集合的get方法获取其对应的值即可 map.put(2,"wanwu"); map.put(3, "zhaoliu"); Set<Integer> keySet = map.keySet(); Iterator<Integer> iterator=keySet.iterator(); while(iterator.hasNext()){ Integer key=iterator.next(); String valueString=map.get(key); System.out.println(key+"..."+valueString); } } public static void method(Map<Integer,String>map){ //添加元素,学号和姓名 System.out.println(map.put(8, "zhangsan")); System.out.println(map.put(8, "lisi")); map.put(1,"wanwu"); map.put(3,"zhaoqi"); //删除 System.out.println("remove:"+map.remove(8)); //判断 System.out.println("containskey:"+map.containsKey(1)); //获取 System.out.println("get:"+map.get(1)); } public static void method3(Map<Integer,String>map){ map.put(2,"lisi"); map.put(1, "wangwu"); /* * 通过map.values调用只取出值而不取出键 * */ Collection<String> values=map.values(); Iterator<String> it1=values.iterator(); while(it1.hasNext()){ System.out.println(it1.next()); } /* * 通过map转成set就可以迭代 * 找到了另一个方法，entryset * 该方法将键和值的映射关系作为对象存储到了set集合中， * 而这个映射关系的类型就是map.Entry类型（结婚证） * * **/ Set<Map.Entry<Integer,String>> entryset = map.entrySet(); Iterator<Map.Entry<Integer,String>> iterator=entryset.iterator(); while(iterator.hasNext()){ Map.Entry<Integer,String> me=iterator.next(); Integer key=me.getKey(); String value=me.getValue(); System.out.println(key+":::::"+value); } } } ② import java.util.HashMap; import java.util.Iterator; public class mapdemo2 { public static void main(String[] args){ /** * 将学生对象和学生的归属地通过键与值存储到map集合中 * */ HashMap<Person,String> hm=new HashMap<Person,String>(); hm.put(new Person(20,"lisi"),"北京"); hm.put(new Person(21,"zhangsan"),"南京"); hm.put(new Person(21,"zhangsan"),"广东"); //Set<Person> keyset=hm.keySet(); //Iterator<Person> iterator=keyset.iterator(); /** * 以上两句可以用下面一句代替 * */ Iterator<Person> iterator=hm.keySet().iterator(); while(iterator.hasNext()){ Person keyPerson=iterator.next(); String value=hm.get(keyPerson); System.out.println(keyPerson.getName()+"..."+keyPerson.getAge()+"..."+value); } } } ③ class Person implements Comparable{ private int age; private String name; public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public boolean equals(Object arg0) { // TODO Auto-generated method stub if(this == arg0) return true; if(!(arg0 instanceof Person)) throw new ClassCastException("类型错误！"); Person p = (Person)arg0; return this.name.equals(p.name) && this.age== p.age; } @Override public int hashCode() { // TODO Auto-generated method stub return name.hashCode()+age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Person(int age, String name) { super(); this.age = age; this.name = name; } public Person() { super(); // TODO Auto-generated constructor stub } @Override public int compareTo(Object arg0) { // TODO Auto-generated method stub Person person= (Person)arg0; int temp=this.age-person.age; return temp==0?this.name.compareTo(person.name):temp; } } ④ import java.util.Map; import java.util.TreeMap; import java.util.Iterator; public class Treemap { public static void main(String[] args){ /** * 将学生对象和学生的归属地通过键与值存储到map集合中 * */ TreeMap<Person,String> hm=new TreeMap<Person,String>(new comparebyname()); hm.put(new Person(23,"lisi"),"北京"); hm.put(new Person(21,"zhangsan"),"南京"); hm.put(new Person(21,"zhangsan"),"广东"); //Set<Person> keyset=hm.keySet(); //Iterator<Person> iterator=keyset.iterator(); /** * 以上两句可以用下面一句代替 * */ Iterator<Map.Entry<Person,String>> iterator=hm.entrySet().iterator(); while(iterator.hasNext()){ Map.Entry<Person,String> me =iterator.next(); Person keyPerson =me.getKey(); String value=me.getValue(); System.out.println(keyPerson.getName()+"..."+keyPerson.getAge()+"..."+value); /* * Person keyPerson=iterator.next(); String value=hm.get(keyPerson); System.out.println(keyPerson.getName()+"..."+keyPerson.getAge()+"..."+value); * */ } } } ⑤ import java.util.Comparator; public class comparebyname implements Comparator { @Override /** * 创建了一个根据person类的name创建的比较器 * */ public int compare(Object arg0, Object arg1) { // TODO Auto-generated method stub Person p1=(Person)arg0; Person p2=(Person)arg1; //int temp =p1.getName().compareTo(p2.getName()); //return temp ==0?p1.getAge()-p2.getAge():temp; return 1; } }
正则表达式案例：<span style="font-size:14px;">import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegerDemo { public static void main(String[] args) { // TODO Auto-generated method stub /* * 正则表达式对字符串的常见操作 * 1.匹配 * matches方法 * 2.切割 * string 类中的split方法 * 3.替换 * string类中的replaceAll(); * * */ //fuction1(); //function2(); //function3(); function4(); } public static void function4() { /* * 将正则规则进行对象的封装 * Pattern p=Pattern.compile(a*b); *通过正则对象的matcher方法字符串相关联，获取要对字符串操作的匹配器对象Matcher *Matcher m=p.matcher("abdsdgfsd"); *tongg matcher匹配器的方法对字符串进行操作 *boolean b=m.matches(); * * */ // TODO Auto-generated method stub String string="da jia hao jin tian bu shi shang bang"; String regex="\\b[a-z]{3}\\b"; //将正则封装成对象 Pattern p=Pattern.compile(regex); //通过正则对象获取匹配器 Matcher m=p.matcher(string); //使用matcher对象的方法对字符进行操作 while(m.find()){//查找 System.out.println(m.group());//获取匹配到的序列 System.out.println(m.start()+":"+m.end()); } } public static void function3() { // TODO Auto-generated method stub String s="13760869551"; //先封装成组（）；再替换组 s=s.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2"); System.out.println(s); } public static void function2() { // TODO Auto-generated method stub String s="zhangshanttttlishi####wanwu"; String[] nameString=s.split("(.)\\1+"); for (String name : nameString ) { System.out.println(name); } } public static void fuction1() { //匹配手机号码是否正确 String teString="13580150008"; String regex="1[385][0-9]{9}"; boolean b=teString.matches(regex); System.out.println(teString+":"+b); } } package Fanshe; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; public class GZHS { public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException { // TODO Auto-generated method stub /* * 获取构造class中的函数 * */ getmethod1(); getmethod2(); } public static void getmethod2() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { // TODO Auto-generated method stub //获取带参数的构造函数 /* * 当获取指定名称对应类中的所体现的对象时 * 而该对象初始化不使用空参数构造该怎么办？ * 既然是通过指定的构造函数进行对象的初始化 * 所以应该先获取到该构造函数，通过字节码文件对象即可完成 * 该方法时：getconstructor(paramterTypes); * */ String name="Test.Person"; //找寻该名称文件，并加载进内场，产生class对象 Class clazz=Class.forName(name); //获取指定对象的构造器函数对象 Constructor constructor=clazz.getConstructor(int.class,String.class); //通过该构造器对象的newinstance方法进行对象的初始化 Object object=constructor.newInstance(12,"小米"); } public static void getmethod1() throws ClassNotFoundException, InstantiationException, IllegalAccessException { // TODO Auto-generated method stub //获取不带参数的构造函数 String nameString="Test.Person"; //找寻该名称类文件，并加载进内存，并产生class对象 Class classz=Class.forName(nameString); //如何产生该类的对象？ Object object=classz.newInstance(); } } package Fanshe; import Test.Person; public class FS { public static void main(String[] args) throws ClassNotFoundException { /* * 获取类的 * 字节码文件 * .class * */ getclass1(); getclass2(); getclass3(); } public static void getclass3() throws ClassNotFoundException { // TODO Auto-generated method stub /* * 通过class的forname（）方法获取 * 只要通过给定的字符串名称就可以获取该类，更为扩展 * 可以用class类中的方法完成 * 该方法时forname * 则中方式只要有名称即可，更为方便 * * */ String clasz="Test.Person"; Class class12=Class.forName(clasz); System.out.println(class12); } public static void getclass2() { // TODO Auto-generated method stub /* * 通过静态成员属性.class获取 * 任何数据类型都具备一个静态的属性 * class来获取对呀的class对象 * 相对简单。但是还是要明确用到类中的静态成员 * * */ Class c=Person.class; Class z=Person.class; System.out.println(z==c); } public static void getclass1() { // TODO Auto-generated method stub /* * 方法一： * 通过类名获取class * */ Person person=new Person(); Class clazz=person.getClass(); Class clazz1=person.getClass(); System.out.println(clazz==clazz1); } } package Fanshe; import java.lang.reflect.Field; public class GetZiDuan { public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException { // TODO Auto-generated method stub /* * 获取字段 * 例如：获取Person类中的age字段 * * */ String nameString="Test.Person"; Class clazz=Class.forName(nameString); Field field=clazz.getDeclaredField("age");//可以获取私有的字段 //Field fid=clazz.getField("age");//不能获取私有的字段 //对私有字段的访问取消访问检查，暴力访问 field.setAccessible(true); Object object=clazz.newInstance(); field.set(object, 80); Object o=field.get(object); System.out.println(o); } } package Fanshe; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class FanFa { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException { // TODO Auto-generated method stub /* * 获取函数方法 * * */ //getmethod1(); getmethod2(); getmethod3(); } public static void getmethod3() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { // TODO Auto-generated method stub Class clazzx=Class.forName("Test.Person"); Method method=clazzx.getMethod("method",String.class,int.class); Object obj=clazzx.newInstance(); method.invoke(obj, "小强",37); } public static void getmethod2() throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException { // TODO Auto-generated method stub Class clazz=Class.forName("Test.Person"); Method method=clazz.getMethod("show",null); Constructor constructor=clazz.getConstructor(int.class,String.class); Object object1=constructor.newInstance(37,"小名"); // method.invoke(object1, null); // method.invoke(object, 37,"小气"); } public static void getmethod1() throws ClassNotFoundException, NoSuchMethodException, SecurityException { // TODO Auto-generated method stub //获取.class中的 函数 Class clazz=Class.forName("Test.Person"); // Method[] methods=clazz.getMethods();//获取的都是公有的方法 Method[] methods=clazz.getDeclaredMethods();//获取的都是私有的方法 for(Method method:methods) { System.out.println(method); } } }</span>
集合知识点和案例
collection
三大容器：list set map
list：
vector arraylist linkedlist
set：
hashset treeset
linkedhashset
map：
hashmap treemap
linkedhashmap
比较器：
compareable <-->comparator
一：哈希表确定元素是否相同
1.判断的是两个元素的哈希值是否相同，
如果相同，再判断两个对象的内容是否相同。
2.判断哈希值相同，其实判断的是对象的hashCode的方法，
判断内容相同，用的是equals方法
注意：如果哈希值不同，是不需要判断equals
二：
set：元素不可重复，是无序的。
set接口和collection方法一致
|--HashSet：内部结构是哈希表，是不同步的。
如何保证该集合的元素唯一性呢？
通过对象的hashcode和equals方法来完成对象唯一性的。
如果对象的hashcode值不同，那么不用判断equals方法，就直接存储到哈希表中。
如果对象的hashcode值相同，那么要再次判断对象的equals方法是否为true。
如果为true，视为相同元素，不存，如果为false，那么视为不同元素，就进行存储。
注意：如果元素要存储到hashset集合中，必须覆盖hashcode方法和equals方法
一般情况下，如果定义的累会产生很多对象，比如人、学生、书，通常都需要覆盖equals、hashcode方法，建立对象判断是否相同的依据。
|--TreeSet可以对set集合中的元素进行排序。是不同步的
判断元素唯一性的方式：就是根据 比较方法的返回结果是否是0，是0就是相同元素，不存。
TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，就需要实现comparable接口，覆盖compareto方法
如果不要按照对象中具备的自然顺序进行排序，如果对象中不具备自然顺序，怎么办？
可以使用TreeSet集合第二种排序方式二：
让集合自身具备比较功能，定义一个类实现comparator接口，覆盖compare方法，将该类对象作为参数传递给Treeset集合的构造函数
if（this.hashcode()==obj.hashcode && this.equals(obj)）
①List： import java.awt.List; import java.util.ArrayList; import java.util.Arrays; public class list {//list可以 完成以下功能 /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub //添加 //void add(index,element); //void add(index,collection); /** * 删除： * object remove(index); * * 修改： * object set(index,element); * * 获取： * object get(index); * int indexof(object); * int lastIndexof(object); * List sublist(from ,to);//包含头不包含尾 * */ ArrayList lis = new ArrayList(); show(lis); } public static void show(ArrayList lis) { // TODO Auto-generated method stub //增： lis.add("abc1"); lis.add("abc2"); lis.add("abc3"); System.out.println(lis); //删除： lis.remove(2); System.out.println(lis); //修改： lis.set(1,"abc8"); System.out.println(lis); //获取： //lis.get(1); System.out.println("get:"+ lis.get(1)); //获取子列表(包含头不包含尾) //lis.subList(1,2); System.out.println("sub:"+lis.subList(0,2)); } } ② import java.util.ArrayList; import java.util.List; import java.util.ListIterator; public class listdemo { //list的取出元素方式 /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub List list = new ArrayList(); //show(list); show1(list); } public static void show1(List list) { // TODO Auto-generated method stub list.add("abc1"); list.add("abc2"); list.add("abc3"); System.out.println(list); ListIterator it= list.listIterator();//获取迭代器对象，可以实现在迭代过程中完成对元素的增删改查 //只有list才具備該功能 //也可以從指定位置開始如： //ListIterator it=list.listIterator(2);//迭代器從第二個元素開始遍歷 while(it.hasNext()){ Object obj= it.next(); if(obj.equals("abc2")){ it.add("abc9");} } System.out.println(list); System.out.println(it.hasNext());//判斷是否具有下一個元素 System.out.println(it.hasPrevious());//逆向遍歷 } // public static void show(List list) { // list.add("abc"); // list.add("abc1"); // list.add("abc3"); // // // //list取出元素的方法一 // Iterator it = list.iterator(); // while(it.hasNext()){ // // System.out.println("next"+it.next()); // } // // //list特有的取出元素方式 // for(int x=0;x<list.size();x++){ // // System.out.println(list.get(x)); // } // } } ③Person类 class Person implements Comparable{ private int age; private String name; public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public boolean equals(Object arg0) { // TODO Auto-generated method stub if(this == arg0) return true; if(!(arg0 instanceof Person)) throw new ClassCastException("类型错误！"); Person p = (Person)arg0; return this.name.equals(p.name) && this.age== p.age; } @Override public int hashCode() { // TODO Auto-generated method stub return name.hashCode()+age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Person(int age, String name) { super(); this.age = age; this.name = name; } public Person() { super(); // TODO Auto-generated constructor stub } @Override public int compareTo(Object arg0) { // TODO Auto-generated method stub Person person= (Person)arg0; int temp=this.age-person.age; return temp==0?this.name.compareTo(person.name):temp; } } ④LinkList import java.util.LinkedList; /** * addFirst(); * addLast(); * * * * getFirst();//获取但不移除，如果链表为空，抛出NoSuchElementException * getLast()； * jdk1.6 * peekFirst();//获取但不移除，如果链表为空，返回null * peekLast(); * * * * * removeFirst();//获取但不移除，如果链表为空，抛出NoSuchElementException * removeLast(); * jdk1.6 * pollFirst();//获取但不移除，如果链表为空，返回null * pollLast(); * * * * * */ class DuiLie{ private LinkedList link; public DuiLie() { // TODO Auto-generated constructor stub link = new LinkedList(); } public void myAdd(Object object){ link.add(object); } public Object myGet(){ return link.removeFirst(); } public boolean isNull(){ return link.isEmpty(); } } public class LinkListdemo { /** * @param args * 请使用linkedlist来模拟一个堆栈或者队列数据结构 * * 堆栈：先进后出，first in last out * * * 队列：先进先出 * * LinkeList 内部是链表数据结构，不同步，增删元素的速度快 */ public static void main(String[] args) { // TODO Auto-generated method stub DuiLie dl= new DuiLie(); dl.myAdd("abc1"); dl.myAdd("abc2"); dl.myAdd("abc3"); while(!dl.isNull()){ System.out.println(dl.myGet()); } } } ⑤Linkedhashset import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashSet; import javax.swing.text.html.HTMLDocument.HTMLReader.IsindexAction; // public class Linkedhashsetdemo { /** * @param args */ //set：元素不可重复，是无序的。 //set接口和collection方法一致 //|--HashSet：内部结构是哈希表，是不同步的 public static void main(String[] args) { // TODO Auto-generated method stub HashSet hs= new LinkedHashSet();//利用hashset的子类LinkedHashSet实现有序输出 hs.add("lisi"); hs.add("wangwu"); hs.add("lisi"); Iterator iterator =hs.iterator(); while(iterator.hasNext()){ //输出结果无序 System.out.println(iterator.next()); } } } ⑥hashset import java.util.HashSet; import java.util.Iterator; import javax.swing.text.html.HTMLDocument.HTMLReader.IsindexAction; //set：元素不可重复，是无序的。 //set接口和collection方法一致 //|--HashSet：内部结构是哈希表，是不同步的， public class hashsetdemo { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub HashSet hs= new HashSet(); hs.add(new Person(20,"lisi")); hs.add(new Person(20,"wangwu")); hs.add(new Person(20,"lisi")); Iterator iterator =hs.iterator(); while(iterator.hasNext()){ Person p=(Person)iterator.next(); //输出结果无序 System.out.println(p.getAge()+"....."+p.getName()); } } } ⑦Arraylist import java.util.ArrayList; import java.util.Iterator; /** * 熟悉两个快捷键：shift+ctrl+s，快捷创建构造函数等 * shift+ctrl+o，快速复制 * * */ public class Arraylistdemo { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub ArrayList al=new ArrayList(); al.add(new Person(21,"lisi1")); al.add(new Person(22,"lisi2")); al.add(new Person(23,"lisi3")); al.add(new Person(24,"lisi4")); Iterator iterator=al.iterator(); while(iterator.hasNext()){ Person p =(Person) iterator.next(); System.err.println(p.getAge()+"..."+p.getName()); } } } ⑧ import java.util.ArrayList; import java.util.Iterator; public class Arraylisttest { /** * 去除重复 * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub ArrayList al= new ArrayList(); // al.add(new Person(20,"lisi")); // al.add(new Person(22,"lisi1")); // al.add(new Person(21,"lisi")); // al.add(new Person(24,"lisi3")); al.add("lisi"); al.add("wangwu"); al.add("zhaoqian"); al.add("lisi"); System.out.println(al); al = getsingleElenemt(al); System.out.println(al); //ystem.out.println(al.remove(new Person(22,"lisi1"))); System.out.println(al); } private static ArrayList getsingleElenemt(ArrayList al) { // TODO Auto-generated method stub //1.定义一个临时容器 ArrayList temp= new ArrayList(); //2.迭代al集合 Iterator it=al.iterator(); while(it.hasNext()){ Object obj= it.next(); //3.判断被迭代到的元素是否在临时容器存在 if(!temp.contains(obj)){ temp.add(obj); } } return temp; } } ⑨Treeset import java.util.Iterator; import java.util.TreeSet; public class TreeSetTest { /** * TreeSet对元素进行排序的方式一： *让元素自身具备比较功能，就需要实现comparable接口，覆盖compareto方法 * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub //比较器的使用new comparebyname() /* * 可以使用TreeSet集合第二种排序方式二： 让集合自身具备比较功能，定义一个类实现comparator接口，覆盖compare方法， 将该类对象作为参数传递给Treeset集合的构造函数*/ //方法一：实现长度比较 TreeSet ts=new TreeSet(new Comparatorbylength()); ts.add("abv"); ts.add("zzzz"); ts.add("qwrds"); ts.add("w"); Iterator it= ts.iterator(); while(it.hasNext()){ System.out.println(it.next()); } //方法二： /*定义一个类实现comparator接口，覆盖compare方法， 将该类对象作为参数传递给Treeset集合的构造函数*/ TreeSet ts1 = new TreeSet(new comparebyname());//创建的比较器，以比较器为主进线比较 ts1.add(new Person(20,"lisi")); ts1.add(new Person(22,"lisi1")); ts1.add(new Person(21,"lisi")); ts1.add(new Person(24,"lisi3")); Iterator iterator= ts1.iterator(); while(iterator.hasNext()){ Person person =(Person)iterator.next(); System.out.println(person.getAge()+"..."+person.getName()); } } } ⑩Person class Person implements Comparable{ private int age; private String name; public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public boolean equals(Object arg0) { // TODO Auto-generated method stub if(this == arg0) return true; if(!(arg0 instanceof Person)) throw new ClassCastException("类型错误！"); Person p = (Person)arg0; return this.name.equals(p.name) && this.age== p.age; } @Override public int hashCode() { // TODO Auto-generated method stub return name.hashCode()+age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Person(int age, String name) { super(); this.age = age; this.name = name; } public Person() { super(); // TODO Auto-generated constructor stub } @Override public int compareTo(Object arg0) { // TODO Auto-generated method stub Person person= (Person)arg0; int temp=this.age-person.age; return temp==0?this.name.compareTo(person.name):temp; } } 十一、comparebyname import java.util.Comparator; public class comparebyname implements Comparator { @Override /** * 创建了一个根据person类的name创建的比较器 * */ public int compare(Object arg0, Object arg1) { // TODO Auto-generated method stub Person p1=(Person)arg0; Person p2=(Person)arg1; //int temp =p1.getName().compareTo(p2.getName()); //return temp ==0?p1.getAge()-p2.getAge():temp; return 1; } } 十二、comparebylength import java.util.Comparator; public class Comparatorbylength implements Comparator { @Override public int compare(Object arg0, Object arg1) { // TODO Auto-generated method stub String s1= (String )arg0; String s2=(String)arg1; int temp =s1.length()-s2.length(); return temp==0?s1.compareTo(s2):temp; } }
以上是我在学习JAVASE阶段的一些经验和笔记之谈。可能本人学习面还不够广，敬请见谅。不足之处还望指教！最后，希望能对读者有所帮助。
扫一扫
284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
