zoukankan html css js c++ java

Java复习笔记

一、面向对象

1.面向对象三个主要特征

封装

两个含义：把一个对象的属性和方法看成一个密不可分的整体，将两者封装成一个不可分割的独立单位（对象）中；隐藏一些外界不需要的属性和方法。

继承

作用：提高开发效率，减少重复代码；反映事物一般特性的类（主类），在此基础上派生出的特殊事物的类（父类）；

多态

方法重载：方法名称相同，参数不同；对象多态：子类对象与父类对象的相互转换。作用：使得程序抽象程度与简洁程度越高，利于分组协同开发。

2.Java主要的四个内存空间

堆内存空间：保存对象的真正数据，每个对象的属性的内容。
栈内存空间：保存的对象对应的堆内存的空间地址。
全局数据区：保存static类型的属性内容。
全局代码区：保存所有的方法定义。

3.String类的主要方法

charAt(i):取得字符串索引位置字符
toCharArray():字符串转换为字符数组
equals():字符串内容比较
replaceAll("1","2"):将字符串中所有1替换为2
substring():字符串截取
split():字符串拆分

4.this关键字

本类属性

为了让属性看起来有意义，用this.属性来表示本类当中的属性

本类方法

this(参数)，代用本类中的构造方法，实现构造方法之间的互相调用，可以减少重复代码，一般放在构造方法的首行

当前对象

this代表了正在调用类中方法的对象，所有的当前对象都用this表示

5.static关键字

定义属性：使用static定义公共属性（所有对象都可使用），修改的属性内容适用于全部的实例化对象，可直接通过类名称.static属性来进行调用修改
定义方法：static定义的方法，类名称直接调用
作用：没有实例化对象时执行类的某些操作；实现数据的共享
应用：实例化对象个数统计、类属性自动命名等

6.代码块

普通代码块：方法中的代码块
构造块：类中的代码块，单独的{}中的代码，构造块优先于构造方法执行，每次实例化对象都会执行。
静态块：（非主类中）静态块优先于构造块执行，不管有多少实例化对象，只执行一次。（主类中）主类中的静态块优先于主方法执行。

7.类分析

使用类实现简单登录，分析类，主方法只关注结果，验证功能交由其他类完成

import java.util.Scanner;

//登录验证
class LoginValidate {
	private String username;
	private String pwd;

	public LoginValidate(String username, String pwd) {
		this.username = username;
		this.pwd = pwd;
	}

	public boolean isValidate() {
		if (username.equals("zq") && pwd.equals("123")) {
			return true;
		} else {
			return false;
		}
	}
}

// 数据验证
class Operate {
	private String username;
	private String pwd;

	public Operate(String username, String pwd) {
		this.username = username;
		this.pwd = pwd;
		this.exit();
	}

	public void exit() {
		if (username.equals("") || pwd.equals("")) {
			System.out.println("输入数据错误！");
			System.exit(1);
		}
	}

	public void getInfo() {
		if (new LoginValidate(username, pwd).isValidate()) {
			System.out.println("登录成功！");
		} else {
			System.out.println("登录失败！");
		}
	}
}

// 主程序,只关心结果
public class 登录类分析 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入用户名：");
		String username = sc.nextLine();
		System.out.print("请输入密码：");
		String pwd = sc.nextLine();
		Operate op = new Operate(username, pwd);
		op.getInfo();
	}
}

8.内部类实现链表数据结构

待完成！

9.继承的局限

一个子类只能继承一个父类，即不允许多重继承，但允许多层继承。
父类的私有属性能被继承下来，但无法直接使用，可通过get，set方法使用。
继承关系中，如果实例化子类对象，，会默认先调用父类的构造方法。

10.覆写与重载

构造方法不能被继承但能被重载

11.final关键字

相当于一个终结器

定义类：不能被继承
定义方法:不能被子类覆写
定义变量：相当于常量，无法被修改，且常量单词字母全部大写

12.单例设计模式

特点：构造方法被私有化，只能有一个实例化对象，通过static 在类中实例化,外部无法实例化对象
应用：如Windows系统的回收站

class Singleton {
	private static final Singleton instance = new Singleton();

	private Singleton() {
	}

	public static Singleton getInstance() {
		return instance;
	}

	public void print() {
		System.out.println("单例设计模式");
	}
}

public class 单例设计模式 {
	public static void main(String[] args) {
		// Singleton singleton = new Singleton(); //报错，外部无法实例化对象
		Singleton inst = null;
		inst = Singleton.getInstance();
		inst.print();
	}
}

13.多例设计模式

对象是有限个，和单例模式差不多，都是通过构造方法私有化，控制对象的个数
如男女（两个对象），星期（七个对象）

14.抽象类与模板设计模式

包含抽象方法，抽象方法只声明未实现，abstract
抽象类必须有子类，一个子类只能继承一个抽象类
子类必须覆写抽象类中的全部抽象方法
抽象类对象使用对象向上转型的方式，通过子类实例化操作

模板设计模式

抽象类：定义一个模板
在Servlet中应用

abstract class Action { // 定义模板
   public static final int EAT = 1;
   public static final int SLEEP = 3;
   public static final int WORK = 5;
   public static final int RUN = 7;

   public void order(int flag) {
   	switch (flag) {
   	case EAT:
   		this.eat();
   		break;
   	case SLEEP:
   		this.sleep();
   		break;
   	case WORK:
   		this.work();
   		break;
   	case RUN:
   		this.run();
   		break;
   	case EAT + SLEEP + RUN:
   		this.eat();
   		this.sleep();
   		this.run();
   		break;
   	case EAT + WORK:
   		this.eat();
   		this.work();
   		break;
   	case EAT + SLEEP + WORK + RUN:
   		this.eat();
   		this.sleep();
   		this.work();
   		this.run();
   		break;
   	}

   }

   public abstract void eat();
   public abstract void sleep();
   public abstract void work();
   public abstract void run();
}

class Dog extends Action {

   @Override
   public void eat() {
   	System.out.println("狗在吃");
   }

   @Override
   public void sleep() {
   	System.out.println("狗在睡");
   }

   @Override
   public void work() {
   }

   @Override
   public void run() {
   	System.out.println("狗在跑");
   }

}

public class 模板设计模式 {
   public static void main(String[] args) {
   	Action ac1 = new Dog();
   	ac1.order(Action.EAT + Action.SLEEP + Action.RUN);
   }
}

15.接口与工厂设计模式、代理设计模式

接口implements实现对象向上转型进行接口对象的实例化
多重继承；先继承后实现

工厂设计模式

实现程序的可移植性
设置过渡端，，降低耦合

interface Fruit {
	public void eat();
}

class Apple implements Fruit {
	public void eat() {
		System.out.println("吃苹果");
	}
}

class Orange implements Fruit {
	public void eat() {
		System.out.println("吃橘子");
	}
}

class Factory { // 过渡端
	public static Fruit getInstance(String className) {
		if (className.equals("apple")) {
			return new Apple();
		}
		if (className.equals("orange")) {
			return new Orange();
		}
		return null;
	}
}

public class 工厂设计模式 {
	public static void main(String[] args) {
		Fruit f = Factory.getInstance("apple");
		f.eat();
	}
}

代理设计模式

是指一个代理主题来操作真实主题。真实主题执行具体的业务操作，而代理主题负责其他相关业务处理

interface Network {
	public void browse();
}

class Real implements Network {
	public void browse() {
		System.out.println("上网浏览信息");
	}
}

class Proxy implements Network {
	private Network network;

	public Proxy(Network network) {
		this.network = network;
	}

	public void check() {
		System.out.println("检查用户是否合法");
	}

	public void browse() {
		this.check();
		this.network.browse();
	}
}

public class 代理设计模式 {
	public static void main(String[] args) {
		Network net = new Proxy(new Real());
		net.browse();
	}
}

16.Object类

所有类的父类
toString():对象地址
equals():比较两个对象的内存地址数值
可以接收所有的引用数据类型

17.数据转换

字符串转换为基本数据类型：Integer.parseInt()、Double.paraseDouble()、Boolean.paraseBoolean()
int转换为String：String.valueOf()

18.Java异常处理流程

throw与throws的区别

都是异常处理中的关键字
throw:用户手工抛出异常类的实例化对象
throws：表示方法不处理异常，而将异常交给程序被调用处处理

19.泛型

类中的属性或方法的参数类型不在定义时声明，而是在使用时动态设置
泛型只能设置为类

坐标泛型类

class Point<T> {
	private T x;
	private T y;

	public T getX() {
		return x;
	}

	public void setX(T x) {
		this.x = x;
	}

	public T getY() {
		return y;
	}

	public void setY(T y) {
		this.y = y;
	}

}

public class 泛型 {
	public static void main(String[] args) {
		Point<String> point = new Point<String>();
		point.setX("东经100度");
		point.setY("西经200度");
		System.out.println(point.getX() + "," + point.getY());
	}
}

20.枚举

应用

enum Sex {
	MALE, FEMALE;
	private String title;

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}
}

class Person {
	private String name;
	private int age;
	private Sex sex;

	public Person(String name, int age, Sex sex) {
		this.name = name;
		this.age = age;
		this.sex = sex;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}

}

public class 枚举 {
	public static void main(String[] args) {
		Person per = new Person("张三", 20, Sex.MALE);
		System.out.println(per.toString());
	}
}

二、JavaSE

1.进程与线程

进程：程序的一次动态执行过程，经历了程序加载、执行、执行完毕的完整过程，每一个进程至少有两个线程，main和gc
线程：线程是进程的进一步划分，一个进程中有很多线程，线程依附于进程才能够存在,主方法是一个线程
java支持多线程

2.多线程的实现

继承Thread类：覆写run()方法，启动start()方法

class MyThread extends Thread {
	private String title;

	public MyThread(String title) {
		this.title = title;
	}

	@Override
	public void run() {
		for (int i = 0; i < 3; i++) {
			System.out.println(this.title + "运行，x=" + i);
		}
	}
}

public class 多线程 {
	public static void main(String[] args) {
		MyThread th1 = new MyThread("线程A");
		MyThread th2 = new MyThread("线程B");
		MyThread th3 = new MyThread("线程C");
		th1.start();
		th2.start();
		th3.start();
	}
}

实现Runnable接口：避免单继承局限，但仍然需要Thread来启动

class MyThread implements Runnable {
	private String title;

	public MyThread(String title) {
		this.title = title;
	}

	@Override
	public void run() {
		for (int i = 0; i < 3; i++) {
			System.out.println(this.title + "运行，x=" + i);
		}
	}
}

public class 多线程 {
	public static void main(String[] args) {
		MyThread th1 = new MyThread("线程A");
		MyThread th2 = new MyThread("线程B");
		MyThread th3 = new MyThread("线程C");
		new Thread(th1).start();
		new Thread(th2).start();
		new Thread(th3).start();
	}
}

多线程卖票程序

class MyThread implements Runnable {
	private int ticket = 5; // 5张票

	@Override
	public void run() {
		for (int i = 0; i < 50; i++) {
			if (this.ticket > 0) {
				System.out.println("卖票，ticket = " + this.ticket--);
			}

		}
	}
}

public class 多线程 {
	public static void main(String[] args) {
		MyThread th = new MyThread();
		new Thread(th).start();
		new Thread(th).start();
		new Thread(th).start();
	}
}

3.同步与死锁

同步：多个线程操作同一资源，解决安全性问题，是指多个操作在同一时间段内只能有一个线程进行，其他线程要等待此线程完成后才可以继续执行
方式一：同步代码块

class MyThread1 implements Runnable{
	private int ticket = 6;
	@Override
	public void run(){
		for(int i =0;i<10;i++){
			synchronized (this) { //同步代码块
				if(this.ticket>0){
					try{
						Thread.sleep(100);
					}catch(InterruptedException e){
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+"卖票，ticket="+this.ticket--);
				}
			}
		}
	}
}
public class 同步 {
	public static void main(String[] args) {
		MyThread1 mt = new MyThread1();
		new Thread(mt,"票贩子A").start();
		new Thread(mt,"票贩子B").start();
		new Thread(mt,"票贩子C").start();
		new Thread(mt,"票贩子D").start();
		new Thread(mt,"票贩子E").start();
	}
}

方式二：同步方法

class MyThread1 implements Runnable {
	private int ticket = 6;

	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			this.sale();
		}
	}

	public synchronized void sale() { // 同步方法
		if (this.ticket > 0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "卖票，ticket="
					+ this.ticket--);
		}
	}
}

public class 同步 {
	public static void main(String[] args) {
		MyThread1 mt = new MyThread1();
		new Thread(mt, "票贩子A").start();
		new Thread(mt, "票贩子B").start();
		new Thread(mt, "票贩子C").start();
		new Thread(mt, "票贩子D").start();
		new Thread(mt, "票贩子E").start();
	}
}

死锁：两个线程都在等待彼此先完成，造成了程序的停滞状态

生产者消费者问题

解决数据错位
解决数据重复生产和重复取出

class Message {
	private String title;
	private String content;
	private boolean flag = true;

	// flag == true:没有数据，可生产，但是不能取出
	// flag == false:有数据，可以取出，但是不能生产
	public synchronized void set(String title, String content) { // 生产判断
		if (this.flag == false) {
			try {
				super.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.title = title;
		this.content = content;
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.content = content;
		this.flag = false;
		super.notify(); // 可以唤醒wait()
	}

	public synchronized void get() { // 取出判断
		if (this.flag == true) {
			try {
				super.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(this.title + "-->" + this.content);// 取走数据
		this.flag = true;
		super.notify();
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}

	public boolean isFlag() {
		return flag;
	}

	public void setFlag(boolean flag) {
		this.flag = flag;
	}

}

// 生产者
class Producer implements Runnable {
	private Message msg = null;

	public Producer(Message msg) {
		this.msg = msg;
	}

	@Override
	public void run() {
		for (int i = 0; i < 50; i++) {
			if (i % 2 == 0) {
				this.msg.set("标题1", "内容1");
			} else {
				this.msg.set("标题2", "内容2");
			}
		}
	}
}

// 消费者
class Consumer implements Runnable {
	private Message msg = null;

	public Consumer(Message msg) {
		this.msg = msg;
	}

	@Override
	public void run() {
		for (int i = 0; i < 50; i++) {
			this.msg.get();
		}
	}
}

public class 生产者消费者问题 {
	public static void main(String[] args) {
		Message msg = new Message();
		new Thread(new Producer(msg)).start();
		new Thread(new Consumer(msg)).start();
	}
}

三、常用类库

1.StringBuffer类

适用于字符串要频繁修改
append()：拼接
reverse():反转
replace(int start,int end,String str):替换
insert(int offset,数据):插入
delete(start,end):删除

2.System类

arraycooy(原数组，原数组开始点，目标数组，目标数组开始点，长度):数组拷贝
currentTimeMillis():可用来统计运行时间

3.日期操作类

getTime():将Data变为long
SimpleDataFormat():SimpleDataFormat sdf = new SimpleDataFormat("yyyy-MM-dd HH:mm:ss SSS");String str = sdf.format(data);

4.随机数类Random

nextInt(101):0-100的随机数

5.Math类

round():四舍五入

6.Array数组操作类

equals(int[] a,int[] b):相等判断
fill(int[] a,int val):指定内容填充
sort(int[] a):排序
binarySearch(int[] a,int key):二分查找
toString(int[] a):输出数组信息

7.比较器

用作对象的比较排序：如根据年龄对人排序

import java.util.*;

class Person1 implements Comparable<Person1> {
	private String name;
	private int age;

	public Person1(String name, int age) {
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "Person1 [name=" + name + ", age=" + age + "]";
	}

	@Override
	public int compareTo(Person1 o) {
		if (this.age > o.age) {
			return 1;
		} else if (this.age < o.age) {
			return -1;
		} else {
			return 0;
		}
	}

}

public class 比较器 {
	public static void main(String[] args) {
		Person1 per[] = new Person1[] { new Person1("张三", 19),
				new Person1("李四", 18), new Person1("王五", 20) };
		Arrays.sort(per);
		System.out.println(Arrays.toString(per));
	}
}

8.正则表达式

matches(String regex)：正则匹配
replaceAll(String regex,String replacement):替换所有
replaceFrist(String regex,String replacement):替换首个
split(String regex):正则拆分

四、Java IO

1.列出指定目录下的全部内容

import java.io.File;

public class 文件夹 {
	public static void main(String[] args) {
		File file = new File("D:" + File.separator + "桌面");
		print(file);
	}

	public static void print(File file) {
		if (file.isDirectory()) {
			File result[] = file.listFiles();
			if (result != null) {
				for (int i = 0; i < result.length; i++) {
					print(result[i]);//递归打印
				}
			}
			System.out.println(file);
		}
	}
}

2.字节输出流

输出内容到文件

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class 字节输入流 {
	public static void main(String[] args) throws Exception {
		File file = new File("D:" + File.separator + "桌面" + File.separator
				+ "java.txt");
		if (!file.getParentFile().exists()) {// 没有文件夹，就创建
			file.getParentFile().mkdirs();
		}
		OutputStream output = new FileOutputStream(file, true);// true表示追加数据
		String data = "Hello Java .
";
		// output.write(data.getBytes(),0,5); //0,5表示指定字符串
		output.write(data.getBytes());
		output.close();
	}
}

3.字节输入流

读取数据

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;


public class 字节输入流 {
	public static void main(String[] args) throws Exception {
		File file = new File("D:"+File.separator+"桌面"+File.separator+"java.txt");
		if(file.exists()){
			InputStream input = new FileInputStream(file);
			byte data[] = new byte[1024];
			int len = input.read(data);//字节数
			System.out.println(len);
			input.close();
			System.out.println("读取的数据为："+new String(data,0,len));
		}
	}
}

4.字符输出流

public static void main(String[] args) throws Exception {
		File file = new File("D:" + File.separator + "桌面" + File.separator
				+ "java.txt");
		if (!file.getParentFile().exists()) {
			file.getParentFile().mkdirs();
		}
		Writer out = new FileWriter(file);
		String data = "Hello Java .
";
		out.write(data);
		out.close();
	}

5.字符输入流

public static void main(String[] args) throws Exception {
		File file = new File("D:"+File.separator+"桌面"+File.separator+"java.txt");
		if(file.exists()){
			Reader in = new FileReader(file);
			char data[] = new char[1024];
			int len = in.read(data);//字节数
			System.out.println(len);
			in.close();
			System.out.println("读取的数据为："+new String(data,0,len));
		}
	}

6.字节流与字符流的区别

字节流：直接操作的是数据终端，如文件；
字符流：操作的是缓冲区，由缓冲区去输出内容，最后需要关闭或者刷新，不然不能真正输出内容到文件；处理中文用字符流会更好

7.内存操作流

以内存作为操作的终端，不产生临时文件

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class 内存操作流 {
	public static void main(String[] args) throws Exception {
		String str = "hello world.";
		OutputStream output = new ByteArrayOutputStream();
		InputStream input = new ByteArrayInputStream(str.getBytes());
		int temp = 0;
		while ((temp = input.read()) != -1) {
			output.write((char) Character.toUpperCase(temp));
		}
		String newStr = output.toString();
		output.close();
		input.close();
		System.out.println(newStr);
	}
}

8.打印流

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;

public class 打印流 {
	public static void main(String[] args) throws Exception {
		PrintStream tools = new PrintStream(new FileOutputStream(new File("D:"
				+ File.separator + "桌面" + File.separator + "java.txt")));
		String name = "张三";
		int age = 20;
		double score = 99.95452;
		tools.printf("姓名：%s,年龄：%d,成绩：%5.2f", name, age, score);
		tools.close();
	}
}

9.输入

BufferReader buf = new BufferReader(new InputStreamReader(System.in));String str = buf.readLine();
Scanner scan = new Scanner(System.in);scan.next();

10.对象序列化

目的：为保证对象可以以二进制数据的方式进行传输
对象所在类实现java.io.Serializable接口
transient关键字定义的属性不被序列化

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Person2 implements Serializable {
	private String name;
	private int age;
	private transient String pwd;

	public Person2(String name, int age, String pwd) {
		this.name = name;
		this.age = age;
		this.pwd = pwd;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", pwd=" + pwd + "]";
	}

	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 String getPwd() {
		return pwd;
	}

	public void setPwd(String pwd) {
		this.pwd = pwd;
	}
}

public class 对象序列化 {
	public static void main(String[] args) throws Exception {
		Person2 p = new Person2("zhangsan", 20, "asd123");
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
				new File("D:" + File.separator + "桌面" + File.separator
						+ "java.txt")));
		oos.writeObject(p);
		oos.close();
		System.out.println(p.toString());
	}
}

五、网络编程

编写服务器端，客户端连接，发送数据给客户端

服务端

import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;

public class 服务端 {
	public static void main(String[] args) throws Exception {
		ServerSocket server = new ServerSocket(9999);// 开辟监听端口
		System.out.println("服务开始启动...");
		Socket client = server.accept();// 接收客户端连接，程序进入阻塞状态
		PrintStream out = new PrintStream(client.getOutputStream());// 取得指定客户端的输出对象
		out.println("连接服务器成功");
		out.close();
		client.close();
		server.close();
		System.out.println("服务器关闭...");
	}
}

客户端

import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class 客户端 {
	public static void main(String[] args) throws Exception {
		Socket client = new Socket("localhost", 9999);// 连接服务器和端口
		Scanner scan = new Scanner(client.getInputStream());// 取得客户端输入流
		scan.useDelimiter("
");
		if (scan.hasNext()) {
			System.out.println("服务器的回应数据：" + scan.next());
		}
		scan.close();
		client.close();
	}
}

六、类集框架

1.List

允许重复
List list = new ArrayList();
List list = new ArrayList();
add(),contains(),remove(),clear()

2.Set

不允许重复
Set set = new HashSet():无序存放
Set<String set = new TreeSet():有序存放，自动排序

3.Iterator

迭代输出
hasNext():判断是否有下一个值
next():当前元素
remove():移除当前元素

public static void main(String[] args) {
		List<String> all = new ArrayList<String>();
		all.add("hello1");
		all.add("hello2");
		all.add("hello3");
		Iterator<String> iter = all.iterator();
		while(iter.hasNext()){
			String str = iter.next();
			System.out.println(str+"、");
		}
	}

4.双向迭代

public static void main(String[] args) {
		List<String> all = new ArrayList<String>();
		all.add("hello1");
		all.add("hello2");
		all.add("hello3");
		ListIterator<String> iter = all.listIterator();
		System.out.print("前-->后：");
		while(iter.hasNext()){
			String str = iter.next();
			System.out.print(str+"、");
		}
		System.out.print("后-->前：");
		while(iter.hasPrevious()){
			String str = iter.previous();
			System.out.print(str+"、");
		}
	}

5.枚举输出

Enumeration

public static void main(String[] args) {
		Vector<String> all = new Vector<String>();
		all.add("hello1");
		all.add("hello2");
		all.add("hello3");
		Enumeration<String> enu = all.elements();
		while(enu.hasMoreElements()){
			String str = enu.nextElement();
			System.out.print(str+"、");
		}
	}

6.foreach

for(String str:all){}

7.Map

保存键值对，key-value，key不允许重复
put(key,value):保存数据
get(key):通过指定的key得到value
keySet():将map中的所有key以集合的方式返回
entrySet():将map变为set集合
实例化：Map<Integer,String> map = new HashMap<Integer,String>();

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class 偶对象 {
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(3, "lisi");
		map.put(3, "zhangsan");// key重复，被覆盖
		map.put(2, "wangwu");
		map.put(1, "zhaoliu");
		Set<Map.Entry<Integer, String>> set = map.entrySet();// map转换为set
		Iterator<Map.Entry<Integer, String>> iter = set.iterator();
		while (iter.hasNext()) {
			Map.Entry<Integer, String> me = iter.next();
			System.out.println(me.getKey() + "," + me.getValue());
		}
	}
}

8.栈

先进后出

import java.util.Stack;

public class 栈 {
	public static void main(String[] args) {
		Stack<String> all = new Stack<String>();
		all.add("A");
		all.add("B");
		all.add("C");
		System.out.println(all.pop());
		System.out.println(all.pop());
		System.out.println(all.pop());
		System.out.println(all.pop());// 没数据了，抛异常
	}
}

七、数据库操作

1.连接MySQL数据库

需要先下载驱动，然后添加到项目中，右键项目->Build Path->Add External...->选择到自己的驱动jar

package zq;

import java.sql.Connection;
import java.sql.DriverManager;

public class 连接数据库 {
	public static final String DBDRIVER = "com.mysql.jdbc.Driver";
	public static final String DBURL = "jdbc:mysql://localhost:3306/java";
	public static final String DBUSER = "root";
	public static final String DBPWD = "ZQ123789";

	public static void main(String[] args) throws Exception {
		Connection conn = null;
		Class.forName(DBDRIVER);// 加载驱动程序
		conn = DriverManager.getConnection(DBURL, DBUSER, DBPWD);// 连接数据库
		System.out.println(conn);// 输出对象则连接成功
		conn.close();
	}
}

2.Statement操作数据表

创建数据表

create table member(
	mid int PRIMARY KEY,
	name VARCHAR(20) not null,
	age int(3),
	birthday VARCHAR(20),
	note VARCHAR(200),
	CONSTRAINT age CHECK (age BETWEEN 0 and 200)
);

插入数据

package zq;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.util.Date;

public class 连接数据库 {
	public static final String DBDRIVER = "com.mysql.jdbc.Driver";
	public static final String DBURL = "jdbc:mysql://localhost:3306/java";
	public static final String DBUSER = "root";
	public static final String DBPWD = "ZQ123789";

	public static void main(String[] args) throws Exception {
		Connection conn = null; // 每一个Connection对象表示一个数据库连接
		Statement stmt = null; // 数据库操作对象
		Class.forName(DBDRIVER);// 加载驱动程序
		conn = DriverManager.getConnection(DBURL, DBUSER, DBPWD);// 连接数据库
		stmt = conn.createStatement();// 找到Statement接口对象
		String sql = "insert into member(mid,name,age,birthday,note) values" +
				"(1,'张三',20,'1998-10-04','java开发工程师')";
		int len = stmt.executeUpdate(sql);
		System.out.println("更新行数："+len);
		stmt.close();
		conn.close();
	}
}

修改数据

package zq;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.util.Date;

public class 连接数据库 {
	public static final String DBDRIVER = "com.mysql.jdbc.Driver";
	public static final String DBURL = "jdbc:mysql://localhost:3306/java";
	public static final String DBUSER = "root";
	public static final String DBPWD = "ZQ123789";

	public static void main(String[] args) throws Exception {
		Connection conn = null; // 每一个Connection对象表示一个数据库连接
		Statement stmt = null; // 数据库操作对象
		Class.forName(DBDRIVER);// 加载驱动程序
		conn = DriverManager.getConnection(DBURL, DBUSER, DBPWD);// 连接数据库
		stmt = conn.createStatement();// 找到Statement接口对象
		String sql = "update member set name='李四',age=22,note='前端工程师' where mid=1" ;
		int len = stmt.executeUpdate(sql);
		System.out.println("更新行数："+len);
		stmt.close();
		conn.close();
	}
}

删除操作

String sql = "delete from member where mid=1";

查询数据

package zq;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Date;

public class 连接数据库 {
	public static final String DBDRIVER = "com.mysql.jdbc.Driver";
	public static final String DBURL = "jdbc:mysql://localhost:3306/java";
	public static final String DBUSER = "root";
	public static final String DBPWD = "ZQ123789";

	public static void main(String[] args) throws Exception {
		Connection conn = null; // 每一个Connection对象表示一个数据库连接
		Statement stmt = null; // 数据库操作对象
		Class.forName(DBDRIVER);// 加载驱动程序
		conn = DriverManager.getConnection(DBURL, DBUSER, DBPWD);// 连接数据库
		stmt = conn.createStatement();// 找到Statement接口对象
		String sql = "select mid,name,age,birthday,note from member" ;
		ResultSet rs = stmt.executeQuery(sql);//查询数据，返回结果集合
		while(rs.next()){
			int mid = rs.getInt("mid");
			String name = rs.getString("name");//getString()可以接收任意类型的数据
			int age = rs.getInt("age");
			String birthday = rs.getString("birthday");
			String note = rs.getString("note");
			System.out.println(mid+","+name+","+age+","+birthday+","+note);
		}
		rs.close();
		stmt.close();
		conn.close();
	}
}

预处理

package zq;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Date;

import com.mysql.jdbc.PreparedStatement;

public class 连接数据库 {
	public static final String DBDRIVER = "com.mysql.jdbc.Driver";
	public static final String DBURL = "jdbc:mysql://localhost:3306/java";
	public static final String DBUSER = "root";
	public static final String DBPWD = "ZQ123789";

	public static void main(String[] args) throws Exception {
		Connection conn = null; // 每一个Connection对象表示一个数据库连接
		PreparedStatement pstmt = null; // 数据库操作对象
		Class.forName(DBDRIVER);// 加载驱动程序
		conn = DriverManager.getConnection(DBURL, DBUSER, DBPWD);// 连接数据库

		String name = "张珊";
		int age = 18;
		Date birthday = new Date();
		String note = "java 开发工程师";
		String sql = "insert into member(mid,name,age,birthday,note)values(2,?,?,?,?)";

		pstmt = (PreparedStatement) conn.prepareStatement(sql);// 找到Statement接口对象
		pstmt.setString(1, name);
		pstmt.setInt(2, age);
		pstmt.setDate(3, new java.sql.Date(birthday.getTime()));
		pstmt.setString(4, note);

		int len = pstmt.executeUpdate();
		System.out.println("更新行数：" + len);

		pstmt.close();
		conn.close();
	}
}

模糊查询

String column = "name";
String keyWord = "三"；
String sql = "select mid,name,age,birthday,note from member where"+column+"like ?";
......
pstmt.setString(1,"%"+keyWord+"%");
ResultSet rs = pstmt.executeQuery();

查看全文

相关阅读:
IOS开发环境
 IOS开发环境搭建
 Eclipse简明使用教程(java集成开发环境）
分布式相关
 成为架构师之路认识分布式架构
 什么是分布式系统，如何学习分布式系统
 分布式定义
 VIM命令详解
 vim常用命令
 vi/vim 命令使用详解

原文地址：https://www.cnblogs.com/zq98/p/14088329.html