长文慎点，Java学习笔记（六）

这只是一篇我自己学习java的流水账笔记，包含了以下内容，全是基础代码示例，希望对正在学习java的小伙伴有帮助

• java基本算法：基本算法
• java设计模式：设计模式

基本算法

打印100以内的素数

package com.scriptwang.test1;
 
import java.util.Date;
 
/**
 * Created by ScriptWang on 16/12/2.
 * 基本算法
 */
public class Test1 {
    public static void main(String[] args){
        test1();
    }
 
    public static void print(Object o){
        System.out.println(o);
    }
 
 
 
    /**
     * 打印100以内的素数
     * 素数:只能被1和自身整除的数,换句话说,
     * 如果除开1和自身还有另外两个整数相乘可以得到这个数
     * 那么这个数就不是素数
     * 比如2,3,5是素数
     * 而4不是素数
     */
    public static void test1(){
        long time = new Date().getTime();
 
        for(int i=1;i<=100;i++){
            if (isPrime(i)) print(i);
        }
 
        long time1 = new Date().getTime();
        print("Used time : " + (time1 - time) );
    }
 
 
    //判断该数是否是素数
    public static boolean isPrime(int i){
        if (i == 1) return false;//任何时候1都不是素数
        if (i == 2) return true;//任何时候2都是素数
 
        /**
         * 最普遍的方法,一个数传进来,比如5,循环2,3,4(不包括1和自身)
         * 如果找到能够除尽的整数,则返回false,说明该数不是素数
         */
        for (int j=2;j<i;j++) {
            if (i % j == 0){
                return false;
            }
        }
        return true;
    }
 
}

打印九九乘法表

package com.scriptwang.test1;
 
import java.util.Date;
 
/**
 * Created by ScriptWang on 16/12/3.
 * 打印九九乘法表
 */
public class Test2 {
    public static void main(String[] args){
        test1();
    }
 
    //两层循环嵌套
    public static void test1(){
        long time = new Date().getTime();
        for (int i=1;i<=9;i++){
            for (int j=1;j<=i;j++){
                System.out.print(i + "*" + j + "=" + (i*j) + " ");
            }
            System.out.println(" ");
        }
        System.out.println("used time : "+(new Date().getTime() - time));
    }
 
 
 
 
}

打印10000以内的回文数字

package com.scriptwang.test1;
 
import java.util.Date;
 
/**
 * Created by ScriptWang on 16/12/3.
 * 打印10000以内的回文数字
 * 回文数字:一个数字如果正反都表示同一个数字的话
 *         那么这个数字就是回文数字
 *         比如12521,141,252等
 */
public class Test3 {
    public static void main(String[] args){
        test1();
        test2();
    }
 
    //利用字符串反转,缺点:效率低
    public static void test1(){
        long time = new Date().getTime();
        //1~9不是回文数字,不用参加循环
        for (int i=10;i<=10000;i++){
            String oldNum = String.valueOf(i);
 
            //利用StringBuilder的reverse方法反转字符串
            String newNum = new StringBuilder(oldNum).reverse().toString();
            if (newNum.equals(oldNum)) System.out.print(i + " ");
        }
        System.out.println();
        System.out.println("used time:"+ (new Date().getTime() - time));
    }
 
 
    //用%将int中的每个数字提取出来,再重新组装成新的数字,优点:效率高
    //经过测试,此法是字符串取反方法效率的两倍至三倍
    public static void test2(){
        long time = new Date().getTime();
        for (int i=10;i<=10000;i++){
             
            int value = i;//临时保存i的值
            int oldNum = i;//保存i的值，用来和refNum比较
 
            int temp1 = 0;//保存每次乘以10的结果
            int temp2 = 0;//保存每次循环的个位数
            int refNum = 0;//保存结果
 
            /**
             * 一个数去 % 10回得到这个数的最后一位(个位),比如123%10=3,546%10=6;
             * 一个int去除以10会舍去小数点后面的数字,比如int num=123,num=num/10,此时的num为12
             * 下面的算法正是利用了这两个特点,将一个数"倒装"起来.
             */
            while (value > 0){
                //将每次得到的结果乘10达到个位变十位，十位变百位... 的效果
                temp1 = refNum * 10;
 
                //将每次的value值%10，得到当前value值的最一位
                temp2 = value % 10;
                 
                //得到每次处理后的结果
                refNum = temp1 + temp2;
                 
                //更新value，丢掉value的最后以为(因为value是int型的，会丢掉小数)
                //当value只有一位数的时候，valu/10的结果为0推出循环
                value /= 10;
            }
            if (refNum == oldNum) System.out.print(i+" ");
        }
        System.out.println();
        System.out.println("used time:"+ (new Date().getTime() - time));
    }
}

三种排序算法：（选择排序，冒泡排序，插入排序）

/**
 * Created by Script Wang on 2016/12/12.
 */
public class Sort {
    public static void main(String[] args){
        int[] s = new int[20];
        for (int i=0;i<s.length;i++){
            s[i] = (int)(Math.random()*100);
        }
 
        Sort.insertSort(s);
        for (int i=0;i<s.length;i++) System.out.print(s[i]+" ");
    }
 
    /**
     * 选择排序：将第一个（最后一个）数字与之后（前）的所有数字一一比较，如果发现有
     * 比第一个数字还要小（大）的，调换他们的位置;循环完第一次将最小（大）的数字放在
     * 了第一个（最后一个）位置，如此一直循环到最后一个数字位置。
     *
     */
    public static void selectionSort(int[] nums){
        //从开始循环到最后
        for (int i=0,temp=0;i<nums.length;i++) for (int j=i+1;j<nums.length;j++){
            if (nums[i]>nums[j]){
                temp = nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
            }
        }
 
        //从最后循环到开始
        for (int temp=0,i=nums.length-1;i>=0;i--) for (int j=i-1;j>=0;j--){
            if (nums[j]>nums[i]){
                temp = nums[j];
                nums[j] = nums[i];
                nums[i] = temp;
            }
        }
 
    }
 
 
    /**
     * 冒泡排序：从第一个（最后一个数开始），依次比较相邻的两个数，如果左数大于后数，
     * 则调换位置，这样外循环循环一次，就将最大的数选出来放在最右边。
     */
    public static void bubbleSort(int[] nums){
        //从开始循环到最后
        for (int i=0,temp=0;i<nums.length;i++) for (int j=0;j<nums.length-1-i;j++){
            if(nums[j] > nums[j+1]){
                temp = nums[j];
                nums[j] = nums[j+1];
                nums[j+1] = temp;
            }
        }
         
        //从最后循环到开始
        for (int temp=0,i=nums.length-1;i>=0;i--) for (int j=nums.length-1;j>nums.length-1-i;j--){
            if (nums[j-1] > nums[j]){
                temp = nums[j-1];
                nums[j-1] = nums[j];
                nums[j] = temp;
            }
        }
    }
 
 
    /**
     * 插入排序：从第二个数开始，依次插入右边的数，左边的所有数总是排好序的了
     * 如果发现右边将要排序的数大于与之相邻的左边的第一个数，那么内循环break！
     * 比如：1，2，3，4，6外循环循环到6，内循环从6开始循环到2，发现6比4大，则
     * 内循环break！
     *
     */
    public static void insertSort(int[] nums){
        //从开始循环到最后
        for (int i=1,temp=0;i<nums.length;i++) for (int j=i;j>0;j--){
            if (nums[j-1] > nums[j]){
                temp = nums[j-1];
                nums[j-1] = nums[j];
                nums[j] = temp;
            }else break;//特别注意break，插入排序是将一个数插入到已经排好序的序列中
            //如果发现待排序数大于左边的第一个数，那么break
 
        }
         
        //从最后循环到开始
        for (int temp=0,i=nums.length-1-1;i>=0;i--) for(int j=i;j<=nums.length-1-1;j++){
            if (nums[j] > nums[j+1]){
                temp = nums[j];
                nums[j] = nums[j+1];
                nums[j+1] = temp;
            }else break;
        }
 
    }
 
 
}

设计模式

单例模式（Singleton）、多例模式（Multiton）

package com.scriptwang.dp;
 
/**
 * Created by ScriptWang on 16/12/13.
 *
 * 单例模式的特点
 * 1:只能有一个实例
 * 2:它必须自行创建自己(自行进行初始化)
 * 3:必须向整个系统提供这个实例
 *
 * 它有两种实现模式:懒汉式和恶汉式
 */
public class UserClass {
 
    public static void main(String[] args){
        Singleton1 s = Singleton1.getInstance();
        Singleton1 s1 = Singleton1.getInstance();
        System.out.println(s == s1);
        Singleton2 s3 = Singleton2.getInstance();
    }
}
 
 
 
//懒汉式 需要的时候才创建,但是可能会线程不安全,需要同步方法
class Singleton1{
    private static int type;
    private static String name;
    private static Singleton1 s;
    private Singleton1(){}//私有构造方法,不允许别人new
    static {//在类被加载的时候自行初始化变量
        type = 1;
        name = "S";
    }
    //懒汉式:当需要的时候才创建该类的实例
    public synchronized static Singleton1 getInstance(){
        if (s == null) s = new Singleton1();
        return s;
    }
}
 
//恶汉式 在类被加载的时候初始化,可能会引起资源浪费
class Singleton2{
    private static int type;
    private static String name;
    private static Singleton2 s;
    private Singleton2(){}//私有构造方法,不允许别人new
    static {
        type = 1;
        name = "S";
        //恶汉式,在加载该类的时候就创建了该类的实例,而不管需要不需要
        s = new Singleton2();
    }
 
    public static Singleton2 getInstance(){
        return s;
    }
}
        

实现这样一个逻辑：不允许客户端类new产品类，不管客户端调用多少次getInstance方法，始终返回同一个产品。

//产品类
public class Car {
    private static Car c;//使用静态变量，保证每次返回的都是同一辆Car
 
    private Car(){}//构造器私有，不允许别人new
 
    static {//static语句块会在该类被Load的时候执行一次，对变量进行初始化
        c = new Car();
    }
 
    public static Car getInstance(){//自己控制自己产生的过程，相当于静态工厂方法
        //cheak something here
        return c;
    }
 
    public void drive(){
        System.out.println("Car is running...");
    }
}
//客户端类
public class Test {
    public static void main(String[] args){
        Car c = Car.getInstance();//通过Car提供的静态方法拿到Car的实例，此实例的产生过程由Car自己控制（比如检查权限等）
        c.drive();
        Car c1 = Car.getInstance();
        c1.drive();
        System.out.println(c == c1);//打印true，说明c和c1指向同一个对象，这就是所谓的单例模式！
    }
}

单例模式的另一个例子：坦克大战项目中的PropertyManager类，从配置文件中读取属性的时候，不需要每读取一次就new一个java.util.Properties的对象，这样太浪费资源，故使用单例模式！

//测试类
public class Test {
    public static void main(String[] args){
        String name = PropertyManager.getProperty("name");
        System.out.println(name);//打印testMessage，表明读取属性成功
 
        Properties p1 = PropertyManager.getInstance();
        Properties p2 = PropertyManager.getInstance();
        System.out.println(p1 == p2);//打印true，表明无论PropertyManager被怎么调用，其内部只有一个java.util.Properties类的实例（这就是单列模式的应用）
    }
}
 
 
//属性文件，名称：properties
name=testMesage
 
 
//PropertyManager类
import java.io.IOException;
import java.util.Properties;
 
public class PropertyManager {
 
    //在此例中p是单例，无论PropertyManager被怎么调用，内存中只有一个p
    private static Properties p = null;
 
    static {//当类被加载的时候初始化p，且static语句块只执行一次
 
        p = new Properties();
        try {
           p.load(PropertyManager.class.
            getClassLoader().getResourceAsStream(“properties”));//加载名为properties的属性文件
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    private PropertyManager(){}//不允许别人直接new本类的对象
 
    public static String getProperty(String key){//通过p拿到其属性值
        return p.getProperty(key);
    }
 
    public static Properties getInstance(){
        return p;
    }
}

对象池的使用（多例模式）

package com.scriptwang.Test;
 
import java.util.HashSet;
import java.util.Set;
 
/**
 * Created by ScriptWang on 16/11/26.
 *
 * 对象池的使用示例
 */
public class Dog {
    //加载类的时候初始化一个Set对象池,static的
    private static Set<Dog> dogPool = new HashSet<>();
 
    private String name;
    private int age;
 
    //构造方法私有,不允许别人new对象,只允许自己new对象
    private Dog(String name,int age){
        this.name = name;
        this.age = age;
    }
 
    /**
     *
     * @param name
     * @param age
     * @return Dog
     * 工厂方法,在构造对象的时候,如果对象池里有,就返回已有的对象,不再new
     * 如果没有,则将new的对象加入到对象池中,并将其返回
     */
    public static Dog newInstance(String name,int age){
        //循环对象池
        for (Dog dog : dogPool){
            //比较name和age,如果相同,则返回对象池里已有的对象
            if (dog.getName().equals(name) && dog.getAge() == age){
                return dog;
            }
        }
 
        //如果对象池里没有该对象,则new出新对象加入对象池并返回
        Dog dog = new Dog(name, age);
        dogPool.add(dog);
        return dog;
    }
 
 
 
    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;
    }
 
 
    @Override
    public String toString(){
        return "Dog : " + name + " : " + age;
    }
}

简单工厂模式（Simple Factory）

package com.scriptwang.dp;
 
/**
 * Created by ScriptWang on 16/12/13.
 * 简单工厂模式:
 * 有一系列产品,他们都属于某一种产品(Cat,Dog都属于Animal)
 * 创建一个工厂来管理他们,这个工厂称为简单工厂
 * 
 * 扩展性:当新添加一种产品的时候，就要在工厂方法里新添加if...else语句
 */
public class UserClass1 {
    public static void main(String[] args){
        Animal cat = new AnimalFactory().createAnimal(0);
        Animal Dog = new AnimalFactory().createAnimal(1);
    }
}
 
class Animal{
    //...
}
class Cat extends Animal{
    //...
}
 
class Dog extends Animal{
    //...
}
class AnimalFactory{
    public static Animal createAnimal(int type){
        if (type == 0) return new Cat();
        else if (type == 1) return new Dog();
        return null;
    }
}

简单工厂模式与反射机制的结合

//抽象产品
public abstract class Car {
    String name;
    public abstract void drive();//抽象方法，其子类必须实现
    public static void print(Object o){System.out.println(o);}
}
//具体产品Bmw和Benz
public class Bmw extends Car{
    Bmw(){this.name = "bmw";}
    public void drive(){ print(name + " is running!");}
}
 
public class Benz extends Car {
    Benz(){this.name = "Bezn";}
 
    public void drive(){print(name + " is running!");}
}
//简单工厂
public class CarFactory {
    private static Car car = null;
    private CarFactory(){}//private构造方法，禁止别人new对象
 
    public static Car createCar(String CarName){//工厂静态生产方法
        try{//利用反射机制，这样新增加一个产品类并不需要修改工厂类
          car = (Car) Class.forName(CarName).newInstance();
      }catch(Exception){
        e.printStackTrace();
      }
      return car;
    }
}
 
//客户端类
public class UserClass {
    public static void main(String[] agrs){
        String name = “Benz”;//相当于从配置文件读取的字符串
        Car c = CarFactory.createCar(name);//根据字符串用工厂生产产品
        c.drive();//使用产品
    }
}

抽象工厂模式

package com.scriptwang.dp;
 
/**
 * Created by ScriptWang on 16/12/13.
 * 抽象工厂模式:
 * 有一系列产品,他们都属于某一种产品(Cat,Dog都继承自Animal)
 * 有一系列工厂,他们都从一个工厂继承,和产品的继承关系类似.
 * 每一个产品都由一个工厂负责,new的是什么工厂就生产什么产品
 * 
 * 扩展性:当新添一种产品的时候,就要新添加一种与之相对应的工厂
 */
public class UserClass1 {
    public static void main(String[] args){
        //创建的是什么工厂就生产什么
        AnimalFactory a1 = new CatFactory();
        AnimalFactory a2 = new DogFactory();
        Animal cat = a1.createAnimal();//生产了猫
        Animal dog = a2.createAnimal();//生产了狗
    }
}
 
class Animal{
    //...
}
class Cat extends Animal{
    //...
}
 
class Dog extends Animal{
    //...
}
 
 
abstract class AnimalFactory{
    public abstract Animal createAnimal();
}
 
class CatFactory extends AnimalFactory{
    public Animal createAnimal(){
        return new Cat();
    }
}
 
class DogFactory extends AnimalFactory{
    public Animal createAnimal(){
        return new Dog();
    }
}

观察者模式

package com.scriptwang.dp;
 
import java.util.HashSet;
 
/**
 * Created by ScriptWang on 16/12/13.
 * 观察者模式:当被观察者对象作出更改时,被观察者会主动通知观察者,让观察者响应这种更改
 * 
 */
public class UserClass {
    public static void main(String[] args){
        Product p = new Product("《字体设计》",102.8);
        WebObserver web = new WebObserver();
        MailObserver mail = new MailObserver();
        web.Reg(p);
        mail.Reg(p);
        p.setPrice(100.0);
        System.out.println("==split line=====after unReg Observer===");
        mail.unReg(p);
        p.setPrice(10.0);
    }
}
 
 
/**
 * 观察者类
 */
class Observer{
    public void update(Product p){};
     
    //注册自己(把Product的HashSet拿过来,再把自己装进去)
    public void Reg(Product p){
        p.getObservers().add(this);
    }
     
    //撤销自己(把Product的HashSet拿过来,再把自己移除)
    public void unReg(Product p){
        p.getObservers().remove(this);
    }
 
}
 
 
class WebObserver extends Observer{
 
    @Override
    public void update(Product p) {
        String name = p.getName();
        double price = p.getPrice();
        System.out.println("网页助手:"+name + "已经降到"+price+"了!请及时更新网页信息");
    }
 
}
 
class MailObserver extends Observer{
    @Override
    public void update(Product p) {
        String name = p.getName();
        double price = p.getPrice();
        System.out.println("邮箱助手:"+name + "已经降到"+price+"了!");
    }
 
}
 
 
class Product{
    private String name;
    private double price;
    //同HashSet装载观察者对象,HashSet不允许重复值,可避免重复装载
    HashSet<Observer> observers;
     
    Product(String name,double price){
        this.name = name;
        this.price = price;
        //在Product被初始化的时候初始化HashSet
        observers = new HashSet<Observer>();
    }
 
    /**
     * 
     * @return
     * 此方法用于观察者注册与取消注册
     */
    public HashSet<Observer> getObservers(){
        return observers;
    }
 
 
    /**
     * 依次回调Observer的update方法,让Observer作出相应响应
     */
    public void notifyObserver(){
        if (observers != null){
            for (Observer o : observers){
                o.update(this);
            }
        }
    }
 
    public double getPrice() {
        return price;
    }
 
    /**
     * 
     * @param price
     * 当价格变化时通知Observer
     */
    public void setPrice(double price) {
        this.price = price;
        this.notifyObserver();//通知
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
     
}

数据结构：java链表

import java.util.LinkedList;
 
/**
 * Created by Script Wang on 2016/12/14.
 * 单向链表（线性链表）的实现
 * 1：一般说的链表指的是单向链表，只能从一头到另一头，不能反过来
 *    如果是可以从两个方向遍历的，称为双向链表
 * 2：链表的关键点在于它对每个节点的next指针的操作，不论是插入，删除或修改操作
 *    都是去某个或某些节点的next引用！
 *
 */
public class UserClass {
    public static void main(String[] args){
        Mylist list = new Mylist();
        for (int i=0;i<20;i++) list.add(i,new Integer(i));
        System.out.println(list);
    }
}
 
 
class Mylist{
    /**
     * 节点内部类
     */
    class Node {
        Object data;//(数据域)
        Node next;//(指针域)
 
        Node(Object data){
            this.data = data;
            next = null;
        }
        public Object get(){
            return data;
        }
 
        public String toString(){
            return data.toString();
        }
 
    }
 
    Node head;//头节点，是判断链表是否为空，获取链表长度等方法实现的重要成员变量！
 
    Mylist(){
        head = null;
    }
 
    public void clear(){
        head = null;
    }
 
    public boolean isEmpty(){
        if (head == null) return true;
        return false;
    }
 
    public int length(){
        int sum = 0;
        //每循环一次更新n，直到n=null停止循环
        for (Node n = head;n != null;n=n.next) sum++;
        return sum;
    }
 
    /**
     * 拿到某个节点，实质上是循环多少次n=n.next语句
     */
    public Node get(int pos){
        if (pos < 0 || pos > length()) {
            throw new RuntimeException("一共有"+length()+"个对象，你要找啥？");
        }
        Node n = head;
        for (int i=0;i<pos;i++) n=n.next;
        return n;
    }
 
 
 
    public void add(int pos,Object data){
        if(pos < 0) throw new RuntimeException("你要往负方向插？只能往0和正方向插！");
        else if (pos > length()) throw new RuntimeException("下标大于最后一个元素！");
        Node n = new Node(data);
        if (pos == 0 ){
            /**
             * 此处理解需要注意，并不是n.next=head;head=n;n和head就无限循环了
             * 而是：
             * new MyList时，head值初始化为null，换句话说head = null
             * 现在n.next = head;是说n.next指向null，而不是head自身
             * head = n;再令head指向n
             * 因此，最终的结果（在链表里面只有一个元素的时候）
             * 是head -->> n -->> null
             * 而不是 head -->> n -->> head （无限循环，当获取length的时候怎么获取？）
             */
            n.next = head;
            head = n;
        }else if (pos == length()){
            get(length()-1).next = n;
        }else {
            /**
             * 这里的顺序是很有讲究滴，必须
             * First:先把当前位置的Node赋值给n.next引用
             * Second:再把n赋值给当前位置的上一个的next引用
             * 不能颠倒！！！！！
             */
            n.next = get(pos);
            get(pos-1).next = n;
 
        }
 
    }
 
    public Object remove(int pos){
        if(pos < 0) throw new RuntimeException("你要往负方向移除？");
        else if (pos > length()) throw new RuntimeException("下标大于最后一个元素！");
        if (pos == 0) {
            Node n = get(0);
            head = get(1);
            return n.get();
        } else if (pos == (length()-1)) {
            Node n = get(length()-1);
            get(pos-1).next = null;
            return n.get();
 
        } else {
            Node n = get(pos);
            get(pos-1).next = get(pos+1);
            return n.get();
        }
    }
 
    public String toString(){
        StringBuilder sb = new StringBuilder();
        for (Node n = head;n != null;n = n.next) {
            if (get(length()-1) == n) {
                sb.append(n.toString());
                continue;
            }
            sb.append(n.toString()+" , ");
        }
        return "["+sb.toString()+"]";
    }
 
}