成鹏致远 | lcw.cnblogs.com | 2014-02-08

单例设计模式

class Singleton{
private static Singleton instance = new Singleton() ; // 在内部产生本类的实例化对象
public static Singleton getInstance(){ // 通过静态方法取得instance对象
return instance ;
}
private Singleton(){ // 将构造方法进行了封装,私有化
}
public void print(){
System.out.println("Hello World!!!") ;
}
};
public class SingletonDemo05{
public static void main(String args[]){
Singleton s1 = null ; // 声明对象
Singleton s2 = null ; // 声明对象
Singleton s3 = null ; // 声明对象
s1 = Singleton.getInstance() ; // 取得实例化对象
s2 = Singleton.getInstance() ; // 取得实例化对象
s3 = Singleton.getInstance() ; // 取得实例化对象
s1.print() ; // 调用方法
s2.print() ; // 调用方法
s3.print() ; // 调用方法
}
};

代理设计模式

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 ProxyDemo{
public static void main(String args[]){
Network net = null ;
net = new Proxy(new Real()) ;// 指定代理操作
net.browse() ; // 客户只关心上网浏览一个操作
}
};

动态代理设计模式(反射实现)

import java.lang.reflect.InvocationHandler ;
import java.lang.reflect.Proxy ;
import java.lang.reflect.Method ;
interface Subject{
public String say(String name,int age) ; // 定义抽象方法say
}
class RealSubject implements Subject{ // 实现接口
public String say(String name,int age){
return "姓名:" + name + ",年龄:" + age ;
}
};
class MyInvocationHandler implements InvocationHandler{
private Object obj ;
public Object bind(Object obj){
this.obj = obj ; // 真实主题类
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this) ;
}
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
Object temp = method.invoke(this.obj,args) ; // 调用方法
return temp ;
}
};
public class DynaProxyDemo{
public static void main(String args[]){
Subject sub = (Subject)new MyInvocationHandler().bind(new RealSubject()) ;
String info = sub.say("成鹏致远",2) ;
System.out.println(info) ;
}
};

工厂设计模式

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){
Fruit f = null ;
if("apple".equals(className)){ // 判断是否要的是苹果的子类
f = new Apple() ;
}
if("orange".equals(className)){ // 判断是否要的是橘子的子类
f = new Orange() ;
}
return f ;
}
};
public class InterfaceCaseDemo05{
public static void main(String args[]){
Fruit f = Factory.getInstance(args[0]) ; // 实例化接口
if(f!=null){ // 判断是否取得实例
f.eat() ;
}
}
};

高级工厂设计模式(反射实现)

import java.util.Properties ;
import java.io.File ;
import java.io.FileOutputStream ;
import java.io.FileInputStream ;
interface Fruit{
public void eat() ; // 吃水果
}
class Apple implements Fruit{
public void eat(){ // 覆写eat()方法
System.out.println("** 吃苹果");
}
};
class Orange implements Fruit{
public void eat(){
System.out.println("** 吃橘子") ;
}
};
class Init{
public static Properties getPro(){
Properties pro = new Properties() ;
File f = new File("d:\\fruit.properties") ; // 找到属性文件
try{
if(f.exists()){ // 文件存在
pro.load(new FileInputStream(f)) ; // 读取属性
}else{
pro.setProperty("apple","org.lcw.factorydemo.Apple") ;
pro.setProperty("orange","org.lcw.factorydemo.Orange") ;
pro.store(new FileOutputStream(f),"FRUIT CLASS") ;
}
}catch(Exception e){}
return pro ;
}
};
class Factory{
public static Fruit getInstance(String className){
Fruit fruit = null ;
try{
fruit = (Fruit)Class.forName(className).newInstance() ;
}catch(Exception e){
e.printStackTrace() ;
}
return fruit ;
}
};
public class FactoryDemo{
public static void main(String args[]){
Properties pro = Init.getPro() ;
Fruit f = Factory.getInstance(pro.getProperty("apple")) ;
if(f!=null){
f.eat() ;
}
}
};

适配器设计模式

interface Window{        // 定义Window接口,表示窗口操作
public void open() ; // 打开
public void close() ; // 关闭
public void activated() ; // 窗口活动
public void iconified() ; // 窗口最小化
public void deiconified();// 窗口恢复大小
}
abstract class WindowAdapter implements Window{
public void open(){} ; // 打开
public void close(){} ; // 关闭
public void activated(){} ; // 窗口活动
public void iconified(){} ; // 窗口最小化
public void deiconified(){};// 窗口恢复大小
};
class WindowImpl extends WindowAdapter{
public void open(){
System.out.println("窗口打开。") ;
}
public void close(){
System.out.println("窗口关闭。") ;
}
};
public class AdapterDemo{
public static void main(String args[]){
Window win = new WindowImpl() ;
win.open() ;
win.close() ;
}
};

观察者设计模式

import java.util.* ;
class House extends Observable{ // 表示房子可以被观察
private float price ;// 价钱
public House(float price){
this.price = price ;
}
public float getPrice(){
return this.price ;
}
public void setPrice(float price){
// 每一次修改的时候都应该引起观察者的注意
super.setChanged() ; // 设置变化点
super.notifyObservers(price) ;// 价格被改变
this.price = price ;
}
public String toString(){
return "房子价格为:" + this.price ;
}
};
class HousePriceObserver implements Observer{
private String name ;
public HousePriceObserver(String name){ // 设置每一个购房者的名字
this.name = name ;
}
public void update(Observable o,Object arg){
if(arg instanceof Float){
System.out.print(this.name + "观察到价格更改为:") ;
System.out.println(((Float)arg).floatValue()) ;
}
}
};
public class ObserDemo01{
public static void main(String args[]){
House h = new House(1000000) ;
HousePriceObserver hpo1 = new HousePriceObserver("购房者A") ;
HousePriceObserver hpo2 = new HousePriceObserver("购房者B") ;
HousePriceObserver hpo3 = new HousePriceObserver("购房者C") ;
h.addObserver(hpo1) ;
h.addObserver(hpo2) ;
h.addObserver(hpo3) ;
System.out.println(h) ; // 输出房子价格
h.setPrice(666666) ; // 修改房子价格
System.out.println(h) ; // 输出房子价格
}
};

反射获取类中方法

import java.lang.reflect.Method ;    // 导入构造方法的包
import java.lang.reflect.Modifier ; // 导入构造方法的包
public class TestJava{
public static void main(String args[]){
Class<?> c1 = null ; // 声明Class对象
try{
c1 = Class.forName("java.lang.Math") ; // 实例化对象
}catch(ClassNotFoundException e){
e.printStackTrace() ;
}
Method m[] = c1.getMethods() ; // 取得全部方法
for(int i=0;i<m.length;i++){
Class<?> r = m[i].getReturnType() ; // 得到返回值类型
Class<?> p[] = m[i].getParameterTypes() ; // 取得全部参数的类型
int xx = m[i].getModifiers() ; // 得到修饰符
System.out.print(Modifier.toString(xx) + " ") ; // 输出修饰符
System.out.print(r + " ") ;
System.out.print(m[i].getName()) ;
System.out.print("(") ;
for(int j=0;j<p.length;j++){
System.out.print(p[j].getName() + " " + "arg" + j) ;
if(j<p.length-1){
System.out.print(",") ;
}
}
Class<?> ex[] = m[i].getExceptionTypes() ; // 取出异常
if(ex.length>0){
System.out.print(") throws ") ;
}else{
System.out.print(")") ;
}
for(int j=0;j<ex.length;j++){
System.out.print(ex[j].getName()) ;
if(j<p.length-1){
System.out.print(",") ;
}
}
System.out.println() ;
}
}
};

反射获取类中属性

import java.lang.reflect.Field ;    // 导入构造方法的包
import java.lang.reflect.Modifier ; // 导入构造方法的包
public class TestJava{
public static void main(String args[]){
Class<?> c1 = null ; // 声明Class对象
try{
c1 = Class.forName("java.lang.Math") ; // 实例化对象
}catch(ClassNotFoundException e){
e.printStackTrace() ;
}
{ // 本类属性
Field f[] = c1.getDeclaredFields() ; // 取得本类中的属性
for(int i=0;i<f.length;i++){
Class<?> r = f[i].getType() ; // 得到属性类型
int mo = f[i].getModifiers() ; // 得到修饰符的数字
String priv = Modifier.toString(mo) ; // 还原修饰符
System.out.print("本类属性:") ;
System.out.print(priv + " ") ;
System.out.print(r.getName() + " ") ; // 得到属性类型
System.out.print(f[i].getName()) ; // 输出属性名称
System.out.println(" ;") ;
}
}
{ // 公共属性
Field f[] = c1.getFields() ; // 取得本类中的公共属性
for(int i=0;i<f.length;i++){
Class<?> r = f[i].getType() ; // 得到属性类型
int mo = f[i].getModifiers() ; // 得到修饰符的数字
String priv = Modifier.toString(mo) ; // 还原修饰符
System.out.print("公共属性:") ;
System.out.print(priv + " ") ;
System.out.print(r.getName() + " ") ; // 得到属性类型
System.out.print(f[i].getName()) ; // 输出属性名称
System.out.println(" ;") ;
}
}
}
};

反射修改类中属性

import java.lang.reflect.Field ;
public class InvokeFieldDemo{
public static void main(String args[]) throws Exception{
Class<?> c1 = null ;
Object obj = null ;
c1 = Class.forName("org.lcw.invoke.Person") ; // 实例化Class对象
obj = c1.newInstance() ;
Field nameField = null ;
Field ageField = null ;
nameField = c1.getDeclaredField("name") ; // 取得name属性
ageField = c1.getDeclaredField("age") ; // 取得name属性
nameField.setAccessible(true) ; // 此属性对外部可见
ageField.setAccessible(true) ; // 此属性对外部可见
nameField.set(obj,"成鹏致远") ; // 设置name属性内容
ageField.set(obj,2) ; // 设置age属性内容
System.out.println("姓名:" + nameField.get(obj)) ;
System.out.println("年龄:" + ageField.get(obj)) ;
}
}; /*
package org.lcw.invoke ;
public class Person
private String name ;
private int age ;
public Person(){ // 无参构造
}
public Person(String name,int age){
this(name) ;
this.age = age ;
}
public void setName(String name){
this.name = name ;
}
public void setAge(int age){
this.age = age ;
}
public String getName(){
return this.name ;
}
public int getAge(){
return this.age ;
}
};
*/

反射Setter修改类中属性

import java.lang.reflect.Method ;
public class InvokeSetGet{
public static void main(String args[]){
Class<?> c1 = null ;
Object obj = null ;
try{
c1 = Class.forName("org.lcw.invoke.Person") ; // 实例化Class对象
}catch(Exception e){}
try{
obj = c1.newInstance() ;
}catch(Exception e){}
setter(obj,"name","成鹏致远",String.class) ; // 调用setter方法
setter(obj,"age",2,int.class) ; // 调用setter方法
System.out.print("姓名:") ;
getter(obj,"name") ;
System.out.print("年龄:") ;
getter(obj,"age");
}
/**
Object obj:要操作的对象
String att:要操作的属性
Object value:要设置的属性内容
Class<?> type:要设置的属性类型
*/
public static void setter(Object obj,String att,Object value,Class<?> type){
try{
Method met = obj.getClass().getMethod("set"+initStr(att),type) ; // 得到setter方法
met.invoke(obj,value) ; // 设置setter的内容
}catch(Exception e){
e.printStackTrace() ;
}
}
public static void getter(Object obj,String att){
try{
Method met = obj.getClass().getMethod("get"+initStr(att)) ; // 得到setter方法
System.out.println(met.invoke(obj)) ; // 调用getter取得内容
}catch(Exception e){
e.printStackTrace() ;
}
}
public static String initStr(String old){ // 将单词的首字母大写
String str = old.substring(0,1).toUpperCase() + old.substring(1) ;
return str ;
}
}; /*
package org.lcw.invoke ;
public class Person
private String name ;
private int age ;
public Person(){ // 无参构造
}
public Person(String name,int age){
this(name) ;
this.age = age ;
}
public void setName(String name){
this.name = name ;
}
public void setAge(int age){
this.age = age ;
}
public String getName(){
return this.name ;
}
public int getAge(){
return this.age ;
}
};
*/

经典二叉树排序算法

class BinaryTree
{
class Node
{ // 声明一个节点类
private Comparable data; // 保存具体的内容
private Node left; // 保存左子树
private Node right; // 保存右子树 public Node(Comparable data)
{
this.data = data;
} public void addNode(Node newNode)
{
// 确定是放在左子树还是右子树
if (newNode.data.compareTo(this.data) < 0)
{ // 内容小,放在左子树
if (this.left == null)
{
this.left = newNode; // 直接将新的节点设置成左子树
}
else
{
this.left.addNode(newNode); // 继续向下判断
}
}
if (newNode.data.compareTo(this.data) >= 0)
{ // 放在右子树
if (this.right == null)
{
this.right = newNode; // 没有右子树则将此节点设置成右子树
}
else
{
this.right.addNode(newNode); // 继续向下判断
}
}
} public void printNode()
{ // 输出的时候采用中序遍历
if (this.left != null)
{
this.left.printNode(); // 输出左子树
}
System.out.print(this.data + "\t");
if (this.right != null)
{
this.right.printNode();
}
}
}; private Node root; // 根元素 public void add(Comparable data)
{ // 加入元素
Node newNode = new Node(data); // 定义新的节点
if (root == null)
{ // 没有根节点
root = newNode; // 第一个元素作为根节点
}
else
{
root.addNode(newNode); // 确定是放在左子树还是放在右子树
}
} public void print()
{
this.root.printNode(); // 通过根节点输出
}
}; public class ComparableDemo03
{
public static void main(String args[])
{
BinaryTree bt = new BinaryTree();
bt.add(8);
bt.add(3);
bt.add(3);
bt.add(10);
bt.add(9);
bt.add(1);
bt.add(5);
bt.add(5);
System.out.println("排序之后的结果:");
bt.print();
}
};

经典链表操作算法

class Link{        // 链表的完成类
class Node{ // 保存每一个节点,此处为了方便直接定义成内部类
private String data ; // 保存节点的内容
private Node next ; // 保存下一个节点
public Node(String data){
this.data = data ; // 通过构造方法设置节点内容
}
public void add(Node newNode){ // 将节点加入到合适的位置
if(this.next==null){ // 如果下一个节点为空,则把新节点设置在next的位置上
this.next = newNode ;
}else{ // 如果不为空,则需要向下继续找next
this.next.add(newNode) ;
}
}
public void print(){
System.out.print(this.data + "\t") ; // 输出节点内容
if(this.next!=null){ // 还有下一个元素,需要继续输出
this.next.print() ; // 下一个节点继续调用print
}
}
public boolean search(String data){ // 内部搜索的方法
if(data.equals(this.data)){ // 判断输入的数据是否和当前节点的数据一致
return true ;
}else{ // 向下继续判断
if(this.next!=null){ // 下一个节点如果存在,则继续查找
return this.next.search(data) ; // 返回下一个的查询结果
}else{
return false ; // 如果所有的节点都查询完之后,没有内容相等,则返回false
}
}
}
public void delete(Node previous,String data){
if(data.equals(this.data)){ // 找到了匹配的节点
previous.next = this.next ; // 空出当前的节点
}else{
if(this.next!=null){ // 还是存在下一个节点
this.next.delete(this,data) ; // 继续查找
}
}
}
};
private Node root ; // 链表中必然存在一个根节点
public void addNode(String data){ // 增加节点
Node newNode = new Node(data) ; // 定义新的节点
if(this.root==null){ // 没有根节点
this.root = newNode ; // 将第一个节点设置成根节点
}else{ // 不是根节点,放到最后一个节点之后
this.root.add(newNode) ; // 通过Node自动安排此节点放的位置
}
}
public void printNode(){ // 输出全部的链表内容
if(this.root!=null){ // 如果根元素不为空
this.root.print() ; // 调用Node类中的输出操作
}
}
public boolean contains(String name){ // 判断元素是否存在
return this.root.search(name) ; // 调用Node类中的查找方法
}
public void deleteNode(String data){ // 删除节点
if(this.contains(data)){ // 判断节点是否存在
// 一定要判断此元素现在是不是根元素相等的
if(this.root.data.equals(data)){ // 内容是根节点
this.root = this.root.next ; // 修改根节点,将第一个节点设置成根节点
}else{
this.root.next.delete(root,data) ; // 把下一个节点的前节点和数据一起传入进去
}
}
}
};
public class LinkDemo02{
public static void main(String args[]){
Link l = new Link() ;
l.addNode("A") ; // 增加节点
l.addNode("B") ; // 增加节点
l.addNode("C") ; // 增加节点
l.addNode("D") ; // 增加节点
l.addNode("E") ; // 增加节点
System.out.println("======= 删除之前 ========") ;
l.printNode() ;
// System.out.println(l.contains("X")) ;
l.deleteNode("C") ; // 删除节点
l.deleteNode("D") ; // 删除节点
l.deleteNode("A") ; // 删除节点
System.out.println("\n====== 删除之后 =========") ;
l.printNode() ;
System.out.println("\n查询节点:" + l.contains("B")) ;
}
};

经典生产者与消费者算法(多线程同步互斥)

class Info
{ // 定义信息类
private String name = "成鹏致远"; // 定义name属性
private String content = "学生"; // 定义content属性
private boolean flag = false; // 设置标志位 public synchronized void set(String name, String content)
{
if (!flag)
{
try
{
super.wait();
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
this.setName(name); // 设置名称
try
{
Thread.sleep(300);
} catch (InterruptedException e)
{
e.printStackTrace();
}
this.setContent(content); // 设置内容
flag = false; // 改变标志位,表示可以取走
super.notify();
} public synchronized void get()
{
if (flag)
{
try
{
super.wait();
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
try
{
Thread.sleep(300);
} catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println(this.getName() + " --> " + this.getContent());
flag = true; // 改变标志位,表示可以生产
super.notify();
} public void setName(String name)
{
this.name = name;
} public void setContent(String content)
{
this.content = content;
} public String getName()
{
return this.name;
} public String getContent()
{
return this.content;
}
}; class Producer implements Runnable
{ // 通过Runnable实现多线程
private Info info = null; // 保存Info引用 public Producer(Info info)
{
this.info = info;
} public void run()
{
boolean flag = false; // 定义标记位
for (int i = 0; i < 50; i++)
{
if (flag)
{
this.info.set("个人博客", "http://lcw.cnblogs.com"); // 设置名称
flag = false;
}
else
{
this.info.set("个人网站", "http://infodown.tap.cn"); // 设置名称
flag = true;
}
}
}
}; class Consumer implements Runnable
{
private Info info = null; public Consumer(Info info)
{
this.info = info;
} public void run()
{
for (int i = 0; i < 50; i++)
{
this.info.get();
}
}
}; public class Test_Format
{
public static void main(String args[])
{
Info info = new Info(); // 实例化Info对象
Producer pro = new Producer(info); // 生产者
Consumer con = new Consumer(info); // 消费者
new Thread(pro).start();
new Thread(con).start();
}
};

String对正则表达式的支持

import java.util.regex.Pattern ;
import java.util.regex.Matcher ;
public class RegexDemo06{
public static void main(String args[]){
String str1 = "A1B22C333D4444E55555F".replaceAll("\\d+","_") ;
boolean temp = "1983-07-27".matches("\\d{4}-\\d{2}-\\d{2}") ;
String s[] = "A1B22C333D4444E55555F".split("\\d+") ;
System.out.println("字符串替换操作:" + str1) ;
System.out.println("字符串验证:" + temp) ;
System.out.print("字符串的拆分:") ;
for(int x=0;x<s.length;x++){
System.out.print(s[x] + "\t") ;
}
}
};

代码块说明

class Demo{
{ // 直接在类中编写代码块,称为构造块
System.out.println("1、构造块。") ;
}
static{ // 使用static,称为静态代码块
System.out.println("0、静态代码块") ;
}
public Demo(){ // 定义构造方法
System.out.println("2、构造方法。") ;
}
};
public class CodeDemo03{
static{ // 在主方法所在的类中定义静态块
System.out.println("在主方法所在类中定义的代码块") ;
}
public static void main(String args[]){
new Demo() ; // 实例化对象
new Demo() ; // 实例化对象
new Demo() ; // 实例化对象
}
};

取得当前时间最简便算法

import java.util.*; // 导入需要的工具包
import java.text.*; // 导入SimpleDateFormat所在的包 class DateTime
{ // 以后直接通过此类就可以取得日期时间
private SimpleDateFormat sdf = null; // 声明SimpleDateFormat对象 public String getDate()
{ // 得到的是一个日期:格式为:yyyy-MM-dd HH:mm:ss.SSS
this.sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
return this.sdf.format(new Date());// 将当前日期进行格式化操作
} public String getDateComplete()
{ // 得到的是一个日期:格式为:yyyy年MM月dd日 HH时mm分ss秒SSS毫秒
this.sdf = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒SSS毫秒");
return this.sdf.format(new Date());// 将当前日期进行格式化操作
} public String getTimeStamp()
{ // 得到的是一个时间戳
this.sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
return this.sdf.format(new Date());// 将当前日期进行格式化操作
}
}; public class DateDemo07
{
public static void main(String args[])
{
DateTime dt = new DateTime();
System.out.println("系统日期:" + dt.getDate());
System.out.println("中文日期:" + dt.getDateComplete());
System.out.println("时间戳:" + dt.getTimeStamp());
}
};

字节流文件拷贝算法

import java.io.* ;
public class Copy{
public static void main(String args[]){
if(args.length!=2){ // 判断是否是两个参数
System.out.println("输入的参数不正确。") ;
System.out.println("例:java Copy 源文件路径 目标文件路径") ;
System.exit(1) ; // 系统退出
}
File f1 = new File(args[0]) ; // 源文件的File对象
File f2 = new File(args[1]) ; // 目标文件的File对象
if(!f1.exists()){
System.out.println("源文件不存在!") ;
System.exit(1) ;
}
InputStream input = null ; // 准备好输入流对象,读取源文件
OutputStream out = null ; // 准备好输出流对象,写入目标文件
try{
input = new FileInputStream(f1) ;
}catch(FileNotFoundException e){
e.printStackTrace() ;
}
try{
out = new FileOutputStream(f2) ;
}catch(FileNotFoundException e){
e.printStackTrace() ;
}
if(input!=null && out!=null){ // 判断输入或输出是否准备好
int temp = 0 ;
try{
while((temp=input.read())!=-1){ // 开始拷贝
out.write(temp) ; // 边读边写
}
System.out.println("拷贝完成!") ;
}catch(IOException e){
e.printStackTrace() ;
System.out.println("拷贝失败!") ;
}
try{
input.close() ; // 关闭
out.close() ; // 关闭
}catch(IOException e){
e.printStackTrace() ;
}
}
}
}

菜单选择类设计方法

public class Menu{
public Menu(){
while(true){
this.show() ; // 无限制调用菜单的显示
}
}
public void show(){
System.out.println("===== Xxx系统 =====") ;
System.out.println(" [1]、增加数据") ;
System.out.println(" [2]、删除数据") ;
System.out.println(" [3]、修改数据") ;
System.out.println(" [4]、查看数据") ;
System.out.println(" [0]、系统退出\n") ;
InputData input = new InputData() ;
int i = input.getInt("请选择:","请输入正确的选项!") ;
switch(i){
case 1:{
Operate.add() ; // 调用增加操作
break ;
}
case 2:{
Operate.delete() ; // 调用删除操作
break ;
}
case 3:{
Operate.update() ; // 调用更新操作
break ;
}
case 4:{
Operate.find() ; // 调用查看操作
break ;
}
case 0:{
System.exit(1) ; // 系统退出
break ;
}
default:{
System.out.println("请选择正确的操作!") ;
}
}
}
};

列出指定目录所有文件方法

import java.io.File ;
import java.io.IOException ;
public class FileDemo11{
public static void main(String args[]){
File my = new File("d:" + File.separator) ; // 操作路径
print(my) ;
}
public static void print(File file){ // 递归调用
if(file!=null){ // 判断对象是否为空
if(file.isDirectory()){ // 如果是目录
File f[] = file.listFiles() ; // 列出全部的文件
if(f!=null){ // 判断此目录能否列出
for(int i=0;i<f.length;i++){
print(f[i]) ; // 因为给的路径有可能是目录,所以,继续判断
}
}
}else{
System.out.println(file) ; // 输出路径
}
}
}
};

【Java】经典示例代码的更多相关文章

  1. 正则表达式学习笔记(附:Java版示例代码)

    具体学习推荐:正则表达式30分钟入门教程 .         除换行符以外的任意字符\w      word,正常字符,可以当做变量名的,字母.数字.下划线.汉字\s        space,空白符 ...

  2. JAVA SSM 示例代码

    SSM 即spring+spring mvc+mybatis,开发工具IDEA 1.先看下项目结构如图: 2.主要配置文件 spring-mvc.xml <?xml version=" ...

  3. java 综合示例代码

    package javaenhance.src.cn.itcast.day3; import java.lang.reflect.Constructor; import java.lang.refle ...

  4. kafka的Java客户端示例代码(kafka_2.11-0.8.2.2)

    1.使用Producer API发送消息到Kafka 从版本0.9开始被KafkaProducer替代. HelloWorldProducer.java package cn.ljh.kafka.ka ...

  5. kafka的Java客户端示例代码(kafka_2.12-0.10.2.1)

    使用0.9开始增加的KafkaProducer和KafkaConsumer. Pom.xml <project xmlns="http://maven.apache.org/POM/4 ...

  6. java封装示例代码

    package com.imooc; public class Telphone { private float screen; private float cpu; private float me ...

  7. 0038 Java学习笔记-多线程-传统线程间通信、Condition、阻塞队列、《疯狂Java讲义 第三版》进程间通信示例代码存在的一个问题

    调用同步锁的wait().notify().notifyAll()进行线程通信 看这个经典的存取款问题,要求两个线程存款,两个线程取款,账户里有余额的时候只能取款,没余额的时候只能存款,存取款金额相同 ...

  8. Java Socket长连接示例代码

    SocketListenerPusher.java代码如下: import java.io.IOException; import java.net.InetSocketAddress; import ...

  9. java 添加一个线程、创建响应的用户界面 。 演示示例代码

    javajava 添加一个线程.创建响应的用户界面 . 演示示例代码 来自thinking in java 4 21章  部分的代码  夹21.2.11 thinking in java 4免费下载: ...

随机推荐

  1. 从源码看Spring Boot 2.0.1

    Spring Boot 命名配置很少,却可以做到和其他配置复杂的框架相同的功能工作,从源码来看是怎么做到的. 我这里使用的Spring Boot版本是 2.0.1.RELEASE Spring Boo ...

  2. Python + Selenium + AutoIt 模拟键盘实现另存为、上传、下载操作详解

    前言 在web页面中,可以使用selenium的定位方式来识别元素,从而来实现页面中的自动化,但对于页面中弹出的文件选择框,selenium就实现不了了,所以就需引用AutoIt工具来实现. Auto ...

  3. 【原创】ABP之IConventionalDependencyRegistra接口分析

    类图: 作用: abp中默认把对象的注册分为5中约定注册方式: 1.AbpAspNetCoreConventionalRegistrar public class AbpAspNetCoreConve ...

  4. 用python批量生成简单的xml文档

    最近生成训练数据时,给一批无效的背景图片生成对应的xml文档,我用python写了一个简单的批量生成xml文档的demo,遇见了意外的小问题,记录一下. 报错问题为:ImportError: No m ...

  5. 【洛谷】1600:天天爱跑步【LCA】【开桶】【容斥】【推式子】

    P1600 天天爱跑步 题目描述 小c同学认为跑步非常有趣,于是决定制作一款叫做<天天爱跑步>的游戏.<天天爱跑步>是一个养成类游戏,需要玩家每天按时上线,完成打卡任务. 这个 ...

  6. MySql md5加密 sqlserver md5加密 C# md5加密 java md5加密

    便民md5加密: 百度md5加密: MySQL 加密语法: MD5(加密字符串) -- 中文加密 SELECT MD5('你好') -- 中文加密匹配查询 SELECT * FROM 表名 WHERE ...

  7. C语——宏小结

    c语言关于宏的使用十分频繁.但是宏的使用有利也有弊,与此同时,它还是一个特别容易搞错的地方.正是基于此,它常常成为一些面试会侧重考察的地方. 所谓宏就是 #define 机制包括的一个规定,即允许把参 ...

  8. oracle的start with connect by prior如何使用

    oracle的start with connect by prior是根据条件递归查询"树",分为四种使用情况: 第一种:start with 子节点ID='...' connec ...

  9. 【Qt5】Windows下配置程序的产品、公司、版权、版本号等详细信息

    在工程的pro文件中加入下面的配置 # 配置图标(仅Windows有效)# 本程序使用两个图标,这样其快捷方式可以有更多选择,也可以给关联文件提供图标选择RC_ICONS += icon1.ico \ ...

  10. 用.Net打造一个移动客户端(Android/IOS)的服务端框架NHM(四)——Android端Http访问类(转)

    本章目的 在上一章中,我们利用Hibernate Tools完成了Android Model层的建立,依赖Hibernate Tools的强大功能,自动生成了Model层.在本章,我们将继续我们的项目 ...