欢迎访问悦橙教程（wld5.com），关注java教程。悦橙教程  java问答|  每日更新
页面导航 : > > > 文章正文

JAVASE学习总结，javase总结

来源： javaer 分享于  点击 14430 次 点评：50

JAVASE学习总结，javase总结


学习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；

三种循环语句： 
While循环 （先判断，后执行）
while(布尔表达式) 
循环体； 
do-while循环（先执行，后判断）
do 
循环体；
  while(布尔表达式);
For循环（格式简洁，变量变化点明确）
for(初值; 布尔表达式; 步长值)
循环体；


（四）类和对象 修饰符

继承性 一个类能继承另一个类的所有属性和行为的机制。
格式：
   class 子类名称 [extends 父类名称] 
   { }
   注意事项:
       如果[extends 父类名称] 不存在，则子类继承自Object类,即所有类直接或间接继承自Object类。
覆盖和重载的区别： 方法覆盖和方法重载是类的多态性的两种表现。
方法覆盖
子类的成员方法与父类的成员方法具有相同的头部（名称和参数）。
父类中的方法不能是private类型的。
覆盖的方法的访问权限必须大于等于被覆盖方法的访问权限。例如：被覆盖方法的访问权限是“friendly”，那么覆盖的方法的访问权限可以是“friendly”、protected、public。
方法重载
     在同一个类中，具有多个同名但不同参数的方法。 注意：声明为static的 方法不能被覆盖。
被final 修饰的方法不能被覆盖。 super是用在子类和父类之间，this是用在本类的构造函数间
抽象类 格式： abstract class 类名
{     …
      abstract 返回值类型 方法名（参数列表）；
     …
}
 注意事项：
抽象方法无方法体。
抽象方法必须置于抽象类中

 接口 格式 [public] interface 接口名[extends 父接口名列表]
{
   [public][static][final]  变量名= 常量值；     //常量声明
[public][abstract] 返回值类型 方法名(参数列表) 
    //抽象方法声明


}
注意事项
接口可实现类间多重继承。
接口是一组常量和抽象方法的集合。
接口里的常量默认是用public static final标识的 。
接口中的所有方法的修饰符都是 public abstract。


包 包是一组相关的类或接口的集合, 它提供了访问保护和名字空间管理。Java编译器使用文件系统目录来保存包。
 程序员能将相互关联的类放在同一包中。
程序员能很方便地了解到在哪里可以找到能完成特定功能的类 
由于每个包都创建了一个名字空间，个人创建的类名不会和其它包中的类名发生冲突 
可以使同一包中的类彼此不加限制地访问，而同时对其它包中的类提供访问控制。

异常 异常处理： 异常处理的两种方法：捕捉异常和抛出异常。
自定义异常。

   当出现程序无法控制的外部环境问题(用户提供的文件不存在，文件内容损坏，网络不可用...)时，Java就会用异常对象来描述。 
异常处理
       异常处理是编写应用程序解决异常
注意事项：
有些异常非常隐蔽，在编译时不能发现。
一旦引发异常，程序将突然中止。
发生异常后此前分配的所有资源都将保留在相同的状态，这将导致资源漏洞。

 异常体系结构
补充说明 Error 不能由应用程序直接处理，必须交由操作系统处理。很少发生，但是一旦发生，通常是致命的
Exception
RuntimeException(运行时异常)
RuntimeException的子类异常。Java编译器允许程序不对它们做出处理。(包含大多数常见异常，如：0做除数，无效数组索引等)
Other Exception(非运行时异常)
除了运行时异常之外的其他由Exception继承来的异常类。Java编译器要求程序必须捕获或声明这种异常，否则编译就报错。(比如：数据库的操作可能导致的异常)
异常的处理方法： 1、处理异常--try/catch/finally
     一旦捕获异常，马上进行处理：
     在方法中使用try/catch/finally语句自己处理异常。 格式：
try {
  . . . // 可能会发生异常的程序块
}
catch (异常类名1   异常对象1) 
{
  . . . // 处理类型1的异常
}
catch (异常类名2  异常对象2) 
{
  . . . // 处理类型2的异常
}
2、抛出异常--throws
      捕获异常，但并不处理，交由调用方处理，即
      将异常的处理递交给当前方法的调用者去处理，称为抛出异常。
throws就是放在类与方法后面, 要调用这个类与方法时,直接将类或方法抛出异常，交给调用者处理。
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 >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 >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 >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 >
</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 >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 >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 >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 >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阶段的一些经验和笔记之谈。可能本人学习面还不够广，敬请见谅。不足之处还望指教！最后，希望能对读者有所帮助。



            
                
	


  







相关文章
    暂无相关文章








相关文章




用户点评