求100到200的素数(质数)

/**
 * @author 玖洲林
 * Create Time 2019-08-17 下午 07:16
 */
public class PrimeNumber {
    public static void main(String[] args) {
        //100 - 300 中所有素数(质数) 1不是素数(质数) 素数大于1
        int num = getPrimeNumber(100, 200);
        System.out.println("共有" + num + "个素数(质数)");
    }

    private static int getPrimeNumber(int start, int end) {
        int num = 0;
        for (int i = start; i <= end; i++) {
            if(i > 1){
                boolean flag = true;
                for (int y = 2; y < i; y++) {
                    if (i % y == 0) {
                        flag = false;
                        break;
                    }

                }

                if (flag) {
                    System.out.println(i + "是素数(质数)");
                    num += 1;
                }
            }
        }
        return num;
    }
}

结果:

      101是素数(质数)
      103是素数(质数)
      107是素数(质数)
      109是素数(质数)
      113是素数(质数)
      127是素数(质数)
      131是素数(质数)
      137是素数(质数)
      139是素数(质数)
      149是素数(质数)
      151是素数(质数)
      157是素数(质数)
      163是素数(质数)
      167是素数(质数)
      173是素数(质数)
      179是素数(质数)
      181是素数(质数)
      191是素数(质数)
      193是素数(质数)
      197是素数(质数)
      199是素数(质数)
      共有21个素数(质数)

斐波那契数列

/**
 * 斐波那契
 * @author 玖洲林
 * Create Time 2019-08-17 下午 07:03
 */
public class Fibonacci {
    public static void main(String[] args) {
        int num = getFibonacci(7);
        System.out.println(num);
    }
    // 1 1 2 3 5 8 13
    private static int getFibonacci(int index) {
        if(index < 0) {
            return -1;
        } else if (index == 0){
            return 0;
        } else if (index <= 2){
            return 1;
        } else {
            int c = 0,b = 1,a = 1;
            for (int i = 3; i <= index; i++) {
                c = a + b;
                a = b;
                b = c;
            }
            return c;
        }
    }
}

使用静态内部类来实现单例多线程

import java.io.ObjectStreamException;
import java.io.Serializable;

/**
 * @author 玖洲林
 * Create Time 2019-08-17 下午 06:41
 */
public class Singleton implements Serializable {

    private static class SingletonHandler {
        private static final Singleton INSTANCE = new Singleton();
    }

    private Singleton() {
    }

    public static Singleton getInstance() {
        return SingletonHandler.INSTANCE;
    }

    private Object readResolve() throws ObjectStreamException {
        //反序列化
        return SingletonHandler.INSTANCE;
    }

}

单例多线程

/**
 * 多线程下的 单例
 * @author 玖洲林
 * Create Time 2019-08-17 下午 06:41
 */
public class Singleton {

    private static Singleton INSTANCE;

    static {
        INSTANCE = new Singleton();
    }

    public static Singleton getInstance(){
        if(INSTANCE == null){
            synchronized (Singleton.class){
                if(INSTANCE == null){
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

黑色星期五

import java.text.SimpleDateFormat;
import java.util.Calendar;

/**
 * 计算今年的黑色星期五
 * @author 玖洲林
 * Create Date 2019-08-16 下午 04:27
 */
public class h5 {
    public static void main(String[] args) {
        //每个月的第13天为星期五则称之为黑色星期五
        //获取当前时间
        Calendar nowDate = Calendar.getInstance();
        //获取年
        int year = nowDate.get(Calendar.YEAR);
        //设置月份为1月( 1 - 1 )
        nowDate.set(Calendar.MONTH,0);
        //设置天数为 13日
        nowDate.set(Calendar.DAY_OF_MONTH,13);
        //规范控制台输出格式 yyyy-MM-dd
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //如果‘年’ 等于 ‘年’ 则循环 (2019 == 2019) true
        while (nowDate.get(Calendar.YEAR) == year){
            //判断是否为星期五(在国外每个星期的第一天为星期日,所以要减一)
            if(nowDate.get(Calendar.DAY_OF_WEEK) - 1 == 5){
                //输出
                System.out.println(sdf.format(nowDate.getTime()) + "是黑色星期五");
            }
            //月份 + 1 (当月份加到 12 在 + 1 时 年份会增加 循环条件将不成立 将结束循环)
            nowDate.add(Calendar.MONTH,1);
        }
        //return;
    }
}

冒泡排序

import java.util.Arrays;

/**
 * 冒泡排序
 * @author 玖洲林
 * Create Date 2019-08-16 下午 04:27
 */
public class h5 {
    public static void main(String[] args) {
        int[] nums = {9,7,58,24,24,28,15,74,51,574,145};
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = 0; j < nums.length - 1 - i; j++) {
                if(nums[j] > nums[j + 1]){
                    int temp = nums[j];
                    nums[j] = nums[j+1];;
                    nums[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(nums));
        //输出结果 [7, 9, 15, 24, 24, 28, 51, 58, 74, 145, 574]
    }
}

Java基础应用题 – 梅花桩

package com.nzdev.dao;

/**
 * @author 玖洲丿林
 * @version 1.0
 * Date 2019/6/27
 * Time 13:46
 */
public class Test {
    public static void main(String[] args) {
        //要走的步数
        int buShu = 50;
        //所在位置
        int zhuang = 1;
        //为false则向右走 为true则向左走
        boolean fangXiang = false;
        //循环五十次 从1到50
        for(int i = 1 ; i <= buShu ; i++){
            //判断方向
            if(fangXiang){
                //当前为向左走
                //判断是否到达第一个桩
                if(zhuang == 1){
                    //设置方向 向右走
                    fangXiang = false;
                    zhuang++;
                }else{
                    //如果还没有到达第一个桩,继续向左走
                    zhuang --;
                }
            }else{
                //当前为向右走
                //判断是否到达第八个桩
                if(zhuang == 8){
                    //设置方向 向左走
                    fangXiang = true;
                    zhuang--;
                }else{
                    //如果还没有到达第八个桩,继续向右走
                    zhuang ++;
                }
            }
            //输出当前位置、步数、方向
            System.out.println("第" + i + "步,第" + zhuang + "桩,向" + (fangXiang ? "左" : "右") + "走");
        }
    }
}

HikariCP地址池 – Java

package com.nzdev.util;

import com.zaxxer.hikari.HikariDataSource;

import java.sql.Connection;
import java.util.ResourceBundle;

/**
 * @author 玖洲丿林
 * 使用HikariCP地址池获取数据库连接
 */
public class HikariUtil {
    //Hikari Datasource
    /**
     * 驱动
     */
    private static String driverClassName = "";
    /**
     * 数据库URL
     */
    private static String jdbcUrl = "";
    /**
     * 数据库用户名
     */
    private static String username = "";
    /**
     * 数据库密码
     */
    private static String password = "";
    /**
     * 只读
     */
    private static boolean readOnly = false;
    /**
     * 等待连接池分配连接的最大时长(毫秒)
     */
    private static int connectionTimeout;
    /**
     * 连接idle状态的最大时长(毫秒)
     */
    private static int idleTimeout;
    /**
     * 连接的生命时长(毫秒)
     */
    private static int maxLifetime;
    /**
     * 连接池允许的最大连接数
     */
    private static int maximumPoolSize;


    private static HikariDataSource dataSource = null;

    /**
     *
     */
    static {
        dataSource = new HikariDataSource();
        //读取配置文件
        readProper("HikariConfig");
        //设置配置
        dataSourceConfig();
    }

    /**
     * 读取数据库配置文件
     * @param propertitleFileName 配置文件名
     * @exception java.io.FileNotFoundException,java.io.IOException
     */
    private static void readProper(String propertitleFileName){
        try {
            ResourceBundle bundle = ResourceBundle.getBundle(propertitleFileName);
            driverClassName = bundle.getString("driverClassName");
            jdbcUrl = bundle.getString("jdbcUrl");
            username = bundle.getString("username");
            password = bundle.getString("password");
            readOnly = Boolean.parseBoolean(bundle.getString("readOnly"));
            connectionTimeout = Integer.parseInt(bundle.getString("connectionTimeout"));
            idleTimeout = Integer.parseInt(bundle.getString("idleTimeout"));
            maxLifetime = Integer.parseInt(bundle.getString("maxLifetime"));
            maximumPoolSize = Integer.parseInt(bundle.getString("maximumPoolSize"));
        } catch (Exception e){
            System.err.println("读取数据库参数出现问题:" + e);
            //throw  e;
        }
    }

    /**
     * 设置dataSource各个属性值
     * @exception Exception
     */
    private static void dataSourceConfig(){
        try {
            /**
             * 驱动类位置
             */
            dataSource.setDriverClassName(driverClassName);
            /**
             * 数据库地址
             */
            dataSource.setJdbcUrl(jdbcUrl);
            /**
             * 数据库用户名
             */
            dataSource.setUsername(username);
            /**
             * 数据库密码
             */
            dataSource.setPassword(password);
            /**
             * 只读
             */
            dataSource.setReadOnly(readOnly);
            /**
             * 等待连接池分配连接的最大时长(毫秒),超过这个时长还没可用的连接则发生SQLException, 缺省:30秒 -->
             */
            dataSource.setConnectionTimeout(connectionTimeout);
            /**
             *  一个连接idle状态的最大时长(毫秒),超时则被释放(retired),缺省:10分钟 -->
             */
            dataSource.setIdleTimeout(idleTimeout);
            /**
             * 一个连接的生命时长(毫秒),超时而且没被使用则被释放(retired),缺省:30分钟,建议设置比数据库超时时长少30秒,参考MySQL wait_timeout参数(show variables like '%timeout%';) -->
             */
            dataSource.setMaximumPoolSize(maxLifetime);
            /**
             *  连接池中允许的最大连接数。缺省值:10;推荐的公式:((core_count * 2) + effective_spindle_count) -->
             */
            dataSource.setMaximumPoolSize(maximumPoolSize);
        } catch (Exception e){
            System.err.println("设置dataSource各个属性值异常:" + e);
            //throw  e;
        }
    }

    /**
     * 取得数据库连接
     * @return
     * @throws Exception
     */
    public static Connection getConnection(){
        Connection conn = null;
        try {
            conn = dataSource.getConnection();
        } catch (Exception e){
            System.err.println("取得数据库连接时发生异常:" + e);
        }
        return conn;
    }

    public static void freeConnection(Connection conn){
        if ( conn != null ){
            try {
                conn.close();
            } catch (Exception e){
                System.err.println("释放数据库连接时发生异常:" + e.getMessage());
            }
        }
    }
}
driverClassName=org.mariadb.jdbc.Driver
jdbcUrl=jdbc:mariadb://localhost:3306/test
username=root
password=root
readOnly=false
connectionTimeout=30000
idleTimeout=600000
maxLifetime=1800000
maximumPoolSize=60

判断是否为回文数 – Java

package com.nzdev.test;

/**
 * @author 玖洲丿林
 * @version 1.0
 * @date 2019/6/26 11:34
 */
public class Pnumber {
    
    public static void main(String[] args) {
        System.out.println(判断是否为回文数(1234321));
    }

    /**
     * 判断是否为回文数,如果是 返回true 如果不是 返回false
     * @param num
     * @return
     */
    static boolean 判断是否为回文数(int num){
        String str = String.valueOf(num);
        char[] chars = str.toCharArray();
        for (int i = 0,j = chars.length - 1 ; i < chars.length / 2 ; i++ , j--) {
            if(chars[i] != chars[j]){
                return false;
            }
        }
        return true;
    }
}

对封装好的数据进行排序(根据其中某一数据) – Java

public static void main(String[] args) throws ParseException {

        String []names = {"张三","李四","王五"};
        char []sexs = {'男','女','女'};
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date []dates = {sdf.parse("1991-09-08"),sdf.parse("1996-05-08"),sdf.parse("1989-06-08")};
        List<Per> list = new ArrayList<>();
        //添加数据
        for (int i = 0; i < names.length; i++) {
            list.add(new Per(names[i],sexs[i],dates[i]));
        }

        System.out.println("---------------原数据------------------");

        for (Per p : list) {
            System.out.println(p.toString());
        }

        System.out.println("------------排序后的数据----------------");

        list = maopao(list);
        for (Per p : list) {
            System.out.println(p.toString());
        }

        System.out.println("---------------------------------------");
    }

    /**
     * 对封装好的Per中的日期进行冒泡排序
     * @param list  排序前数据
     * @return  排序后数据
     */
    public static List<Per> maopao(List<Per> list){
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = 0; j < list.size() - 1 - i; j++) {
                if(list.get(j).getDate().after(list.get(j + 1).getDate())){
                    Per temp = list.get(j + 1);
                    list.set(j + 1, list.get(j));
                    list.set(j, temp);
                }
            }
        }
        return list;
    }


    static class Per{
        private String name;
        private Character sex;
        private Date date;

        public Per() {
        }

        public Per(String name, Character sex, Date date) {
            this.name = name;
            this.sex = sex;
            this.date = date;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public Character getSex() {
            return sex;
        }

        public void setSex(Character sex) {
            this.sex = sex;
        }

        public Date getDate() {
            return date;
        }

        public void setDate(Date date) {
            this.date = date;
        }

        @Override
        public String toString() {
            return "per{" +
                    "name='" + name + '\'' +
                    ", sex=" + sex +
                    ", date=" + date +
                    '}';
        }
    }