佘大将军
佘大将军

JDK1.8 新特性

JDK1.8 新特性

Lambda表达式
函数式接口
*方法引用和构造器调用
Stream API
接口中的默认方法和静态方法
新时间日期API
在jdk1.8中对hashMap等map集合的数据结构优化。hashMap数据结构的优化
原来的hashMap采用的数据结构是哈希表（数组+链表），hashMap默认大小是16，一个0-15索引的数组，如何往里面存储元素，首先调用元素的hashcode方法，计算出哈希码值，经过哈希算法算成数组的索引值，如果对应的索引处没有元素，直接存放，如果有对象在，那么比较它们的equals方法比较内容如果内容一样，后一个value会将前一个value的值覆盖，如果不一样，在1.7的时候，后加的放在前面，形成一个链表，形成了碰撞，在某些情况下如果链表无限下去，那么效率极低，碰撞是避免不了的
加载因子：0.75，数组扩容，达到总容量的75%，就进行扩容，但是无法避免碰撞的情况发生
在1.8之后，在数组+链表+红黑树来实现hashmap，当碰撞的元素个数大于8时 & 总容量大于64，会有红黑树的引入
除了添加之后，效率都比链表高，1.8之后链表新进元素加到末尾
ConcurrentHashMap (锁分段机制)，concurrentLevel,jdk1.8采用CAS算法(无锁算法，不再使用锁分段)，数组+链表中也引入了红黑树的使用

Lambda表达式
lambda表达式本质上是一段匿名内部类，也可以是一段可以传递的代码

先来体验一下lambda最直观的优点：简洁代码
//匿名内部类

  Comparator cpt = new Comparator() {
  @Override
  public int compare(Integer o1, Integer o2) {
      return Integer.compare(o1,o2);
  }
  };
  TreeSet set = new TreeSet<>(cpt);
  System.out.println("=========================");

  //使用lambda表达式
  Comparator cpt2 = (x,y) -> Integer.compare(x,y);
  TreeSet set2 = new TreeSet<>(cpt2);

只需要一行代码，极大减少代码量！！

这样一个场景，在商城浏览商品信息时，经常会有条件的进行筛选浏览，例如要选颜色为红色的、价格小于8000千的….

// 筛选颜色为红色

public  List filterProductByColor(List list){
List prods = new ArrayList<>();
for (Product product : list){
    if ("红色".equals(product.getColor())){
        prods.add(product);
    }
}
return prods;
 }

// 筛选价格小于8千的

public  List filterProductByPrice(List list){
List prods = new ArrayList<>();
for (Product product : list){
    if (product.getPrice() < 8000){
        prods.add(product);
    }
}
return prods;
 }

我们发现实际上这些过滤方法的核心就只有if语句中的条件判断，其他均为模版代码，每次变更一下需求，都需要新增一个方法，然后复制黏贴，假设这个过滤方法有几百行，那么这样的做法难免笨拙了一点。如何进行优化呢？

优化一：使用设计模式

定义一个MyPredicate接口

public interface MyPredicate  {
    boolean test(T t);
}

如果想要筛选颜色为红色的商品，定义一个颜色过滤类

public class ColorPredicate implements MyPredicate  {

 private static final String RED = "红色";

 @Override
 public boolean test(Product product) {
     return RED.equals(product.getColor());
 }

定义过滤方法，将过滤接口当做参数传入，这样这个过滤方法就不用修改，在实际调用的时候将具体的实现类传入即可。

public List filterProductByPredicate(List list,MyPredicate mp){
    List prods = new ArrayList<>();
    for (Product prod : list){
        if (mp.test(prod)){
            prods.add(prod);
        }
    }
    return prods;
}

例如，如果想要筛选价格小于8000的商品，那么新建一个价格过滤类既可

public class PricePredicate implements MyPredicate {
@Override
public boolean test(Product product) {
    return product.getPrice() < 8000;
}
}

这样实现的话可能有人会说，每次变更需求都需要新建一个实现类，感觉还是有点繁琐呀，那么再来优化一下

优化二：使用匿名内部类

定义过滤方法：

public List filterProductByPredicate(List list,MyPredicate mp){
    List prods = new ArrayList<>();
    for (Product prod : list){
        if (mp.test(prod)){
            prods.add(prod);
        }
    }
    return prods;
}

调用过滤方法的时候：

// 按价格过滤
public void test2(){
filterProductByPredicate(proList, new MyPredicate() {
    @Override
    public boolean test(Product product) {
        return product.getPrice() < 8000;
    }
});
}

 // 按颜色过滤
 public void test3(){
 filterProductByPredicate(proList, new MyPredicate() {
     @Override
     public boolean test(Product product) {
         return "红色".equals(product.getColor());
     }
 });
 }

使用匿名内部类，就不需要每次都新建一个实现类，直接在方法内部实现。看到匿名内部类，不禁想起了Lambda表达式。

优化三：使用lambda表达式

定义过滤方法：

public List filterProductByPredicate(List list,MyPredicate mp){
    List prods = new ArrayList<>();
    for (Product prod : list){
        if (mp.test(prod)){
            prods.add(prod);
        }
    }
    return prods;
}

使用lambda表达式进行过滤

@Test
public void test4(){
  List products = filterProductByPredicate(proList, (p) -> p.getPrice() < 8000);
  for (Product pro : products){
      System.out.println(pro);
  }
  }

在jdk1.8中还有更加简便的操作 Stream API

优化四：使用Stream API

甚至不用定义过滤方法，直接在集合上进行操作

// 使用jdk1.8中的Stream API进行集合的操作
@Test
public void test(){
    // 根据价格过滤
    proList.stream()
       .fliter((p) -> p.getPrice() <8000)
       .limit(2)
       .forEach(System.out::println);

    // 根据颜色过滤
    proList.stream()
       .fliter((p) -> "红色".equals(p.getColor()))
       .forEach(System.out::println);

    // 遍历输出商品名称
    proList.stream()
       .map(Product::getName)
       .forEach(System.out::println);
}

Lmabda表达式的语法总结： () -> ();

前置 语法
无参数无返回值 () -> System.out.println(“Hello WOrld”)
有一个参数无返回值 (x) -> System.out.println(x)
有且只有一个参数无返回值 x -> System.out.println(x)
有多个参数，有返回值，有多条lambda体语句 (x，y) -> {System.out.println(“xxx”);return xxxx;}；
有多个参数，有返回值，只有一条lambda体语句 (x，y) -> xxxx
口诀：左右遇一省括号，左侧推断类型省

注：当一个接口中存在多个抽象方法时，如果使用lambda表达式，并不能智能匹配对应的抽象方法，因此引入了函数式接口的概念

函数式接口
函数式接口的提出是为了给Lambda表达式的使用提供更好的支持。

什么是函数式接口？
简单来说就是只定义了一个抽象方法的接口（Object类的public方法除外），就是函数式接口，并且还提供了注解：@FunctionalInterface

常见的四大函数式接口

Consumer ：消费型接口，有参无返回值

@Test
    public void test(){
    changeStr("hello",(str) -> System.out.println(str));
    }

/**
 *  Consumer 消费型接口
 * @param str
 * @param con
 */
public void changeStr(String str, Consumer con){
    con.accept(str);
}

Supplier 

 @Test
public void test2(){
   String value = getValue(() -> "hello");
   System.out.println(value);
   }

/**
 *  Supplier 供给型接口
 * @param sup
 * @return
 */
public String getValue(Supplier sup){
    return sup.get();
}

Function ：:函数式接口，有参有返回值

@Test
public void test3(){
    Long result = changeNum(100L, (x) -> x + 200L);
    System.out.println(result);
}

/**
 *  Function 函数式接口
 * @param num
 * @param fun
 * @return
 */
public Long changeNum(Long num, Function fun){
    return fun.apply(num);
}

Predicate《T》： 断言型接口，有参有返回值，返回值是boolean类型

public void test4(){
    boolean result = changeBoolean("hello", (str) -> str.length() > 5);
    System.out.println(result);
}

/**
 *  Predicate 断言型接口
 * @param str
 * @param pre
 * @return
 */
public boolean changeBoolean(String str, Predicate pre){
    return pre.test(str);
}

在四大核心函数式接口基础上，还提供了诸如BiFunction、BinaryOperation、toIntFunction等扩展的函数式接口，都是在这四种函数式接口上扩展而来的，不做赘述。

总结：函数式接口的提出是为了让我们更加方便的使用lambda表达式，不需要自己再手动创建一个函数式接口，直接拿来用就好了，贴

方法引用
若lambda体中的内容有方法已经实现了，那么可以使用“方法引用”
也可以理解为方法引用是lambda表达式的另外一种表现形式并且其语法比lambda表达式更加简单

(a) 方法引用
三种表现形式：

  1. 对象：：实例方法名

  2. 类：：静态方法名

  3. 类：：实例方法名 （lambda参数列表中第一个参数是实例方法的调用 者，第二个参数是实例方法的参数时可用）

    public void test() {
 /**
 *注意：
 *   1.lambda体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的函数列表和返回值类型保持一致！
 *   2.若lambda参数列表中的第一个参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用ClassName::method
 *
 */
 Consumer con = (x) -> System.out.println(x);
 con.accept(100);

 // 方法引用-对象::实例方法
 Consumer con2 = System.out::println;
 con2.accept(200);

 // 方法引用-类名::静态方法名
 BiFunction biFun = (x, y) -> Integer.compare(x, y);
 BiFunction biFun2 = Integer::compare;
 Integer result = biFun2.apply(100, 200);

 // 方法引用-类名::实例方法名
 BiFunction fun1 = (str1, str2) -> str1.equals(str2);
 BiFunction fun2 = String::equals;
 Boolean result2 = fun2.apply("hello", "world");
 System.out.println(result2);
 }

(b)构造器引用
格式：ClassName::new

public void test2() {

    // 构造方法引用  类名::new
    Supplier sup = () -> new Employee();
    System.out.println(sup.get());
    Supplier sup2 = Employee::new;
    System.out.println(sup2.get());

    // 构造方法引用 类名::new （带一个参数）
    Function fun = (x) -> new Employee(x);
    Function fun2 = Employee::new;
    System.out.println(fun2.apply(100));
 }

(c)数组引用

格式：Type[]::new

public void test(){
    // 数组引用
    Function fun = (x) -> new String[x];
    Function fun2 = String[]::new;
    String[] strArray = fun2.apply(10);
    Arrays.stream(strArray).forEach(System.out::println);
}

Stream API
Stream操作的三个步骤

创建stream
中间操作（过滤、map）
终止操作
stream的创建：

// 1，校验通过Collection 系列集合提供的stream()或者paralleStream()
List list = new ArrayList<>();
Strean stream1 = list.stream();

// 2.通过Arrays的静态方法stream()获取数组流
String[] str = new String[10];
Stream stream2 = Arrays.stream(str);

// 3.通过Stream类中的静态方法of
Stream stream3 = Stream.of("aa","bb","cc");

// 4.创建无限流
// 迭代
Stream stream4 = Stream.iterate(0,(x) -> x+2);

//生成
Stream.generate(() ->Math.random());

Stream的中间操作:

/**
   * 筛选 过滤  去重
   */
  emps.stream()
      .filter(e -> e.getAge() > 10)
      .limit(4)
      .skip(4)
      // 需要流中的元素重写hashCode和equals方法
      .distinct()
      .forEach(System.out::println);


  /**
   *  生成新的流 通过map映射
   */
  emps.stream()
      .map((e) -> e.getAge())
      .forEach(System.out::println);


  /**
   *  自然排序  定制排序
   */
 emps.stream()
      .sorted((e1 ,e2) -> {
          if (e1.getAge().equals(e2.getAge())){
              return e1.getName().compareTo(e2.getName());
          } else{
              return e1.getAge().compareTo(e2.getAge());
          }
      })
      .forEach(System.out::println);

Stream的终止操作：

 /**
     *      查找和匹配
     *      allMatch-检查是否匹配所有元素
     *      anyMatch-检查是否至少匹配一个元素
     *      noneMatch-检查是否没有匹配所有元素
     *      findFirst-返回第一个元素
     *      findAny-返回当前流中的任意元素
     *      count-返回流中元素的总个数
     *      max-返回流中最大值
     *      min-返回流中最小值
     */

    /**
     *  检查是否匹配元素
     */
    boolean b1 = emps.stream()
            .allMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
    System.out.println(b1);

    boolean b2 = emps.stream()
            .anyMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
    System.out.println(b2);

    boolean b3 = emps.stream()
            .noneMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
    System.out.println(b3);

    Optional opt = emps.stream()
            .findFirst();
    System.out.println(opt.get());

    // 并行流
    Optional opt2 = emps.parallelStream()
            .findAny();
    System.out.println(opt2.get());

    long count = emps.stream()
            .count();
    System.out.println(count);

    Optional max = emps.stream()
            .max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
    System.out.println(max.get());

    Optional min = emps.stream()
            .min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
    System.out.println(min.get());

还有功能比较强大的两个终止操作 reduce和collect
reduce操作： reduce:(T identity,BinaryOperator)/reduce(BinaryOperator)-可以将流中元素反复结合起来，得到一个值

     /**
     *  reduce ：规约操作
     */
    List list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    Integer count2 = list.stream()
            .reduce(0, (x, y) -> x + y);
    System.out.println(count2);

    Optional sum = emps.stream()
            .map(Employee::getSalary)
            .reduce(Double::sum);
    System.out.println(sum);

collect操作：Collect-将流转换为其他形式，接收一个Collection接口的实现，用于给Stream中元素做汇总的方法

    /**
     *  collect：收集操作
     */

    List ageList = emps.stream()
            .map(Employee::getAge)
            .collect(Collectors.toList());
    ageList.stream().forEach(System.out::println);

并行流和串行流
在jdk1.8新的stream包中针对集合的操作也提供了并行操作流和串行操作流。并行流就是把内容切割成多个数据块，并且使用多个线程分别处理每个数据块的内容。Stream api中声明可以通过parallel()与sequential()方法在并行流和串行流之间进行切换。
jdk1.8并行流使用的是fork/join框架进行并行操作

ForkJoin框架
Fork/Join 框架：就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行 join 汇总。
关键字：递归分合、分而治之。
采用 “工作窃取”模式（work-stealing）：
当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线
程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中
相对于一般的线程池实现,fork/join框架的优势体现在对其中包含的任务的
处理方式上.在一般的线程池中,如果一个线程正在执行的任务由于某些原因
无法继续运行,那么该线程会处于等待状态.而在fork/join框架实现中,如果
某个子问题由于等待另外一个子问题的完成而无法继续运行.那么处理该子
问题的线程会主动寻找其他尚未运行的子问题来执行.这种方式减少了线程
的等待时间,提高了性能.。

/**
 * 要想使用Fark—Join，类必须继承
 * RecursiveAction（无返回值）
 * Or
 * RecursiveTask（有返回值）
*
*/
public class ForkJoin extends RecursiveTask {

/**
 * 要想使用Fark—Join，类必须继承RecursiveAction（无返回值） 或者
 * RecursiveTask（有返回值）
 *
 * @author Wuyouxin
 */
private static final long serialVersionUID = 23423422L;

private long start;
private long end;

public ForkJoin() {
}

public ForkJoin(long start, long end) {
    this.start = start;
    this.end = end;
}

// 定义阙值
private static final long THRESHOLD = 10000L;

@Override
protected Long compute() {
    if (end - start <= THRESHOLD) {
        long sum = 0;
        for (long i = start; i < end; i++) {
            sum += i;
        }
        return sum;
    } else {
        long middle = (end - start) / 2;
        ForkJoin left = new ForkJoin(start, middle);
        //拆分子任务，压入线程队列
        left.fork();
        ForkJoin right = new ForkJoin(middle + 1, end);
        right.fork();

        //合并并返回
        return left.join() + right.join();
    }
}

/**
 * 实现数的累加
 */
@Test
public void test1() {
    //开始时间
    Instant start = Instant.now();

    //这里需要一个线程池的支持
    ForkJoinPool pool = new ForkJoinPool();

    ForkJoinTask task = new ForkJoin(0L, 10000000000L);
    // 没有返回值     pool.execute();
    // 有返回值
    long sum = pool.invoke(task);

    //结束时间
    Instant end = Instant.now();
    System.out.println(Duration.between(start, end).getSeconds());
}

/**
 * java8 并行流 parallel()
 */
@Test
public void test2() {
    //开始时间
    Instant start = Instant.now();

    // 并行流计算    累加求和
    LongStream.rangeClosed(0, 10000000000L).parallel()
            .reduce(0, Long :: sum);

    //结束时间
    Instant end = Instant.now();
    System.out.println(Duration.between(start, end).getSeconds());
}

@Test
public void test3(){
    List list = Arrays.asList(1, 2, 3, 4, 5);
    list.stream().forEach(System.out::print);

    list.parallelStream()
        .forEach(System.out::print);
}

展示多线程的效果：

@Test
    public void test(){
    // 并行流 多个线程执行
    List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
    numbers.parallelStream()
            .forEach(System.out::print);

    //
    System.out.println("=========================");
    numbers.stream()
                 .sequential()
                 .forEach(System.out::print);
}

Optional容器
使用Optional容器可以快速的定位NPE，并且在一定程度上可以减少对参数非空检验的代码量。

/**
 *      Optional.of(T t); // 创建一个Optional实例
 *      Optional.empty(); // 创建一个空的Optional实例
 *      Optional.ofNullable(T t); // 若T不为null，创建一个Optional实例，否则创建一个空实例
 *      isPresent();    // 判断是够包含值
 *      orElse(T t);   //如果调用对象包含值，返回该值，否则返回T
 *      orElseGet(Supplier s);  // 如果调用对象包含值，返回该值，否则返回s中获取的值
 *      map(Function f): // 如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty();
 *      flatMap(Function mapper);// 与map类似。返回值是Optional
 *
 *      总结：Optional.of(null)  会直接报NPE
 */

Optional op = Optional.of(new Employee("zhansan", 11, 12.32, Employee.Status.BUSY));
    System.out.println(op.get());

    // NPE
    Optional op2 = Optional.of(null);
    System.out.println(op2);
@Test
public void test2(){
    Optional op = Optional.empty();
    System.out.println(op);

    // No value present
    System.out.println(op.get());
}
@Test
public void test3(){
    Optional op = Optional.ofNullable(new Employee("lisi", 33, 131.42, Employee.Status.FREE));
    System.out.println(op.get());

    Optional op2 = Optional.ofNullable(null);
    System.out.println(op2);
   // System.out.println(op2.get());
}
@Test
public void test5(){
    Optional op1 = Optional.ofNullable(new Employee("张三", 11, 11.33, Employee.Status.VOCATION));
    System.out.println(op1.orElse(new Employee()));
    System.out.println(op1.orElse(null));
}

@Test
public void test6(){
    Optional op1 = Optional.of(new Employee("田七", 11, 12.31, Employee.Status.BUSY));
    op1 = Optional.empty();
    Employee employee = op1.orElseGet(() -> new Employee());
    System.out.println(employee);
}

@Test
public void test7(){
    Optional op1 = Optional.of(new Employee("田七", 11, 12.31, Employee.Status.BUSY));
    System.out.println(op1.map( (e) -> e.getSalary()).get());
}
 
 
接口中可以定义默认实现方法和静态方法
 在接口中可以使用default和static关键字来修饰接口中定义的普通方法
 
 
public interface Interface {
default  String getName(){
    return "zhangsan";
}

static String getName2(){
    return "zhangsan";
}
}

 
 
在JDK1.8中很多接口会新增方法，为了保证1.8向下兼容，1.7版本中的接口实现类不用每个都重新实现新添加的接口方法，引入了default默认实现，static的用法是直接用接口名去调方法即可。当一个类继承父类又实现接口时，若后两者方法名相同，则优先继承父类中的同名方法，即“类优先”，如果实现两个同名方法的接口，则要求实现类必须手动声明默认实现哪个接口中的方法。
 
 
新的日期API LocalDate | LocalTime | LocalDateTime
 新的日期API都是不可变的，更使用于多线程的使用环境中
 
 
@Test
public void test(){
    // 从默认时区的系统时钟获取当前的日期时间。不用考虑时区差
    LocalDateTime date = LocalDateTime.now();
    //2018-07-15T14:22:39.759
    System.out.println(date);

    System.out.println(date.getYear());
    System.out.println(date.getMonthValue());
    System.out.println(date.getDayOfMonth());
    System.out.println(date.getHour());
    System.out.println(date.getMinute());
    System.out.println(date.getSecond());
    System.out.println(date.getNano());

    // 手动创建一个LocalDateTime实例
    LocalDateTime date2 = LocalDateTime.of(2017, 12, 17, 9, 31, 31, 31);
    System.out.println(date2);
    // 进行加操作，得到新的日期实例
    LocalDateTime date3 = date2.plusDays(12);
    System.out.println(date3);
    // 进行减操作，得到新的日期实例
    LocalDateTime date4 = date3.minusYears(2);
    System.out.println(date4);
}

@Test
public void test2(){
    // 时间戳  1970年1月1日00：00：00 到某一个时间点的毫秒值
    // 默认获取UTC时区
    Instant ins = Instant.now();
    System.out.println(ins);

    System.out.println(LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli());
    System.out.println(System.currentTimeMillis());

    System.out.println(Instant.now().toEpochMilli());
    System.out.println(Instant.now().atOffset(ZoneOffset.ofHours(8)).toInstant().toEpochMilli());
}

@Test
public void test3(){
    // Duration:计算两个时间之间的间隔
    // Period：计算两个日期之间的间隔

    Instant ins1 = Instant.now();

    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    Instant ins2 = Instant.now();
    Duration dura = Duration.between(ins1, ins2);
    System.out.println(dura);
    System.out.println(dura.toMillis());

    System.out.println("======================");
    LocalTime localTime = LocalTime.now();
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    LocalTime localTime2 = LocalTime.now();
    Duration du2 = Duration.between(localTime, localTime2);
    System.out.println(du2);
    System.out.println(du2.toMillis());
}

@Test
public void test4(){
    LocalDate localDate =LocalDate.now();

    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    LocalDate localDate2 = LocalDate.of(2016,12,12);
    Period pe = Period.between(localDate, localDate2);
    System.out.println(pe);
}

@Test
public void test5(){
    // temperalAdjust 时间校验器
    // 例如获取下周日  下一个工作日
    LocalDateTime ldt1 = LocalDateTime.now();
    System.out.println(ldt1);

    // 获取一年中的第一天
    LocalDateTime ldt2 = ldt1.withDayOfYear(1);
    System.out.println(ldt2);
    // 获取一个月中的第一天
    LocalDateTime ldt3 = ldt1.withDayOfMonth(1);
    System.out.println(ldt3);

    LocalDateTime ldt4 = ldt1.with(TemporalAdjusters.next(DayOfWeek.FRIDAY));
    System.out.println(ldt4);

    // 获取下一个工作日
    LocalDateTime ldt5 = ldt1.with((t) -> {
        LocalDateTime ldt6 = (LocalDateTime)t;
        DayOfWeek dayOfWeek = ldt6.getDayOfWeek();
        if (DayOfWeek.FRIDAY.equals(dayOfWeek)){
            return ldt6.plusDays(3);
        }
        else if (DayOfWeek.SATURDAY.equals(dayOfWeek)){
            return ldt6.plusDays(2);
        }
        else {
            return ldt6.plusDays(1);
        }
    });
    System.out.println(ldt5);
}

@Test
public void test6(){
    // DateTimeFormatter: 格式化时间/日期
    // 自定义格式
    LocalDateTime ldt = LocalDateTime.now();
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
    String strDate1 = ldt.format(formatter);
    String strDate = formatter.format(ldt);
    System.out.println(strDate);
    System.out.println(strDate1);

    // 使用api提供的格式
    DateTimeFormatter dtf = DateTimeFormatter.ISO_DATE;
    LocalDateTime ldt2 = LocalDateTime.now();
    String strDate3 = dtf.format(ldt2);
    System.out.println(strDate3);

    // 解析字符串to时间
    DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    LocalDateTime time = LocalDateTime.now();
    String localTime = df.format(time);
    LocalDateTime ldt4 = LocalDateTime.parse("2017-09-28 17:07:05",df);
    System.out.println("LocalDateTime转成String类型的时间："+localTime);
    System.out.println("String类型的时间转成LocalDateTime："+ldt4);
}

// ZoneTime  ZoneDate       ZoneDateTime
@Test
public void test7(){
    LocalDateTime now = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
    System.out.println(now);

    LocalDateTime now2 = LocalDateTime.now();
    ZonedDateTime zdt = now2.atZone(ZoneId.of("Asia/Shanghai"));
    System.out.println(zdt);

    Set set = ZoneId.getAvailableZoneIds();
    set.stream().forEach(System.out::println);
}

 
 
补充：
 
 
表示日期的LocalDate
 表示时间的LocalTime
 表示日期时间的LocalDateTime
 
 
新的日期API的几个优点：
 
 
     
  
  • 之前使用的java.util.Date月份从0开始，我们一般会+1使用，很不方便，java.time.LocalDate月份和星期都改成了enum
    •  
  
  • java.util.Date和SimpleDateFormat都不是线程安全的，而LocalDate和LocalTime和最基本的String一样，是不变类型，不但线程安全，而且不能修改。
    •  
  
  • java.util.Date是一个“万能接口”，它包含日期、时间，还有毫秒数，更加明确需求取舍
    •  
  
  •  
    新接口更好用的原因是考虑到了日期时间的操作，经常发生往前推或往后推几天的情况。用java.util.Date配合Calendar要写好多代码，而且一般的开发人员还不一定能写对。
     
     LocalDate
 public static void localDateTest() {

 //获取当前日期,只含年月日 固定格式 yyyy-MM-dd    2018-05-04
 LocalDate today = LocalDate.now();

 // 根据年月日取日期，5月就是5，
 LocalDate oldDate = LocalDate.of(2018, 5, 1);

 // 根据字符串取：默认格式yyyy-MM-dd，02不能写成2
 LocalDate yesteday = LocalDate.parse("2018-05-03");

 // 如果不是闰年 传入29号也会报错
 LocalDate.parse("2018-02-29");
 }

     
    •  
 
 
 
LocalDate常用转化
 
 
/**
 * 日期转换常用,第一天或者最后一天...
 */
public static void localDateTransferTest(){
    //2018-05-04
    LocalDate today = LocalDate.now();
    // 取本月第1天： 2018-05-01
    LocalDate firstDayOfThisMonth = today.with(TemporalAdjusters.firstDayOfMonth());
    // 取本月第2天：2018-05-02
    LocalDate secondDayOfThisMonth = today.withDayOfMonth(2);
    // 取本月最后一天，再也不用计算是28，29，30还是31： 2018-05-31
    LocalDate lastDayOfThisMonth = today.with(TemporalAdjusters.lastDayOfMonth());
    // 取下一天：2018-06-01
    LocalDate firstDayOf2015 = lastDayOfThisMonth.plusDays(1);
    // 取2018年10月第一个周三 so easy?：  2018-10-03
    LocalDate thirdMondayOf2018 = LocalDate.parse("2018-10-01").with(TemporalAdjusters.firstInMonth(DayOfWeek.WEDNESDAY));
}

 
 
LocalTime
 
 
 public static void localTimeTest(){
    //16:25:46.448(纳秒值)
    LocalTime todayTimeWithMillisTime = LocalTime.now();
    //16:28:48 不带纳秒值
    LocalTime todayTimeWithNoMillisTime = LocalTime.now().withNano(0);
    LocalTime time1 = LocalTime.parse("23:59:59");
}

 
 
LocalDateTime
 
 
public static void localDateTimeTest(){
    //转化为时间戳  毫秒值
    long time1 = LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli();
    long time2 = System.currentTimeMillis();

    //时间戳转化为localdatetime
    DateTimeFormatter df= DateTimeFormatter.ofPattern("YYYY-MM-dd HH:mm:ss.SSS");

    System.out.println(df.format(LocalDateTime.ofInstant(Instant.ofEpochMilli(time1),ZoneId.of("Asia/Shanghai"))));
}
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(JDK1.8 新特性)

        

            

                
    
                    
  • C++八股
                        Petrichorzncu
八股总结c++开发语言
                        
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
    
                    
    • 
                    
  • 华为云分布式缓存服务DCS 8月新特性发布
                        华为云PaaS服务小智
华为云分布式缓存
                        
    分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
    
                    
    • 
                    
  • 【编程底层原理】HashMap Hashtable ConcurrentHashMap
                        Dylanioucn
开发语言后端java
                        
    在Java的不同版本中，集合的实现原理有所变化，尤其是在HashMap、Hashtable和ConcurrentHashMap这三种实现中。以下是它们的一些关键区别和实现原理：一、HashMapJDK1.7：HashMap使用数组和链表的组合来解决冲突。当一个桶（数组的每个位置）中的元素超过一定数量时，会使用链表来存储这些元素。HashMap在JDK1.7中不是线程安全的。JDK1.8：进行了优化
    
                    
    • 
                    
  • 《Android进阶之光》读书笔记
                        soleil雪寂
读书笔记#Android进阶之光
                        
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
    
                    
    • 
                    
  • 《Android进阶之光》— Android 书籍
                        王睿丶
Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
                        
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
    
                    
    • 
                    
  • 【拖拽】自定义拖拽图标
                        风露_

                        
    一、知识点设置被拖拽的元素draggable为true(HTML5新特性)关键方法：voiddataTransfer.setDragImage(img,xOffset,yOffset);注意点：Note:Ifthe[Element]isanexisting[HTMLElement],itneedstobevisibleintheviewportinordertobeshownasadragfeed
    
                    
    • 
                    
  • C# Tuple、ValueTuple
                        語衣
C#知识补充c#
                        
    栏目总目录TupleTuple是C#4.0引入的一个新特性，主要用于存储一个固定数量的元素序列，且这些元素可以具有不同的类型。Tuple是一种轻量级的数据结构，非常适合用于临时存储数据，而无需定义完整的类或结构体。优点简便性：可以快速创建一个包含多个不同类型数据的对象，而无需定义新的类或结构体。灵活性：元素数量和类型在编译时确定，但可以在不同上下文中重复使用不同元素的Tuple。缺点性能：作为引用
    
                    
    • 
                    
  • C++快速入门扫盲总结
                        六竹书生__wa
C/C++Qt
                        
    C++快速入门扫盲总结C++语言新特性C++的新特性C++的输入输出方式C++之命名空间namespaceC++面向对象类和对象构造函数与析构函数this指针继承重载函数重载运算符重载多态数据封装数据抽象接口（抽象类）C++语言新特性C++的新特性C++比C语言新增的数据类型是布尔类型（bool）。但是在新的C语言标准里已经有布尔类型了，但是在旧的C语言标准里是没有布尔类型的，编译器也无法解释布尔
    
                    
    • 
                    
  • SQLServer2022新特性 GENERATE_SERIES函数
                        zxrhhm
sqlserver数据库
                        
    SQLServer2022新特性GENERATE_SERIES函数，在给定间隔内生成一系列数字。序列值之间的间隔和步骤由用户定义。参考官方地址https://learn.microsoft.com/en-us/sql/t-sql/functions/generate-series-transact-sql?view=sql-server-ver161、本文内容语法参数返回类型权限示例相关内容适用于
    
                    
    • 
                    
  • SQL Server中使用异常处理调试存储过程
                        weixin_30583563
数据库c#
                        
    异常处理被普遍认为是T-SQL脚本编程中的最弱的方面。幸运的是，这一点在SQLServer2005中得到了改变，因为SQLServer2005支持结构化异常处理。本文首先关注新特性“TRY……CATCH”的基本构成，然后在SQLServer2000和SQLServer2005中对照着看一些T-SQL的例子，这些例子中使用事务代码故意制造了一些违反约束限制的情况。将来的文章会继续探讨这一主题。在SQ
    
                    
    • 
                    
  • Python3.8 特性介绍
                        刷漆猫咪

                        
    简介海象表达式:=仅位置参数/f-strings说明符=启动异步REPLunittest支持异步简介Python3.8已经发布了,官方文档看这里What’sNewInPython3.8.介绍一些Python3.8中的新特性.海象表达式:=新的语法:=将给变量赋值,这个变量是更大的表达式的一部分.if(n:=len(a))>10:print(f"Lististoolong({n}elements,e
    
                    
    • 
                    
  • SpringBoot3与SpringBoot2的区别
                        bjzhang75
springboot
                        
    文章目录1、JDK环境2、SpringFramework版本3、主要变化和新特性3.1配置变化3.2GraalVM3.3安全性改进3.4性能优化3.4.1启动时间3.4.2内存使用3.5改进的依赖管理3.6全新启动器3.7Kotlin支持SpringBoot3与SpringBoot2的区别1、JDK环境SpringBoot3最低要求JDK17SpringBoot2最低要求JDK82、SpringF
    
                    
    • 
                    
  • 开源项目低代码表单FormCreate从Vue2到Vue3升级指南
                        低代码研究员
FormCreate开源低代码FormCreate低代码表单低代码设计器动态表单
                        
    开源项目低代码表单FormCreatev3版本基于Vue3.0构建，尽管功能与v2版本大致相同，但有一些重要的变更和不兼容项需要注意。源码地址:Github|GiteeFormCreatev3对比v2版本在一些功能和配置项上做了调整，以更好地支持Vue3的新特性。以下是v2到v3升级过程中需要关注的变化和调整。移除配置项在v3版本中，以下配置项已被移除，因为它们在Vue3中不再适用：attrs：在
    
                    
    • 
                    
  • CSS 元素超出部分滚动, 并隐藏滚动条（2种方法）
                        就像风1样
cssCSS样式专栏css溢出滚动隐藏滚动条
                        
    方法一,利用css3的新特性-webkit-scrollbar,但是这种方式不兼容火狐和IE超出部分隐藏滚动条#box{width:500px;height:300px;overflow-x:hidden;overflow-y:scroll;line-height:30px;text-align:center;}#box::-webkit-scrollbar{display:none;}你好你好你
    
                    
    • 
                    
  • 搭建Kafka+zookeeper集群调度
                        krb___
kafka分布式
                        
    前言硬件环境172.18.0.5kafkazk1Kafka+zookeeperKafkaBroker集群172.18.0.6kafkazk2Kafka+zookeeperKafkaBroker集群172.18.0.7kafkazk3Kafka+zookeeperKafkaBroker集群软件环境zookeeper3.5.9资源调度、写作Kafka2.8.0消息通信中间件安装JDK1.8安装搭建zo
    
                    
    • 
                    
  • C++新特性以及应用场景
                        平凡而伟大(心之所向)
编程语言c++开发语言
                        
    C++的新特性可以大致分为以下几类：模板（Templates）：提高代码复用性，包括模板函数和模板类。异常处理（ExceptionHandling）：提供了一套结构化的错误处理机制。异步编程（ConcurrencyandMultithreading）：提供了线程和原子操作等工具。智能指针（SmartPointers）：自动管理内存，如std::unique_ptr和std::shared_ptr。
    
                    
    • 
                    
  • 2019年面试遇到的笔试题
                        程序猿阿峰

                        
    前端面试，肯定是少不了笔试题，果然，今天去面试就遇到的笔试题，慌了一批。回来赶紧整理了一下一、css3的常用的新特性？flex布局和传统布局有什么区别？css3的新特性那就多啦，简单的列举了几个：过渡transition:CSS属性，花费时间，效果曲线(默认ease)，延迟时间(默认0)动画animation：动画名称，一个周期花费时间，运动曲线（默认ease），动画延迟（默认0），播放次数（默认
    
                    
    • 
                    
  • C++20 新特征：概念（Concepts）全面解析
                        jianglq
C++开发C++学习c++20开发语言
                        
    基本概念C++20引入了一个重要的新特性——概念（Concepts）。概念允许你在编写模板时指定模板参数（类型或非类型）应该满足的条件。这种约束使得编译器能够在编译时检查类型是否符合预期，从而提前发现错误，并给出更清晰的错误信息。概念是编译时多态的一种形式，它增强了模板编程的能力，使得代码更加健壮、可读性和可维护性更高。历史演变概念的想法早在C++的设计阶段就已经存在，但由于早期的技术限制和技术挑
    
                    
    • 
                    
  • 【C++新特性】C++17结构化绑定
                        guangcheng0312q
c++编程语言指针hashmapc++11
                        
    1.1更详细的阐述结构化绑定1.1.1绑定到匿名对象1.1.2使用修饰符1.1.3修饰符并非修饰结构化绑定1.1.4移动语义1.2结构化绑定可以在哪使用1.2.1结构体和类1.2.2原生数组1.2.3std::pair,std::tuple和std::array1.3为结构化绑定提供类似tuple的API1.3.1只读结构化绑定1.3.2结构化绑定写操作1.结构化绑定结构化绑定：通过对象的元素或成
    
                    
    • 
                    
  • springboot宠物咖啡馆平台的设计与实现
                        然然学长
springboot宠物java后端intellij-idea开发语言
                        
    运行环境环境说明:开发语言:java框架:springboot，vueJDK版本:JDK1.8数据库:mysql5.7+(推荐5.7，8.0也可以)数据库工具:Navicat11+开发软件:idea/eclipse(推荐idea)Maven包:Maven3.3.9+系统详细实现管理员模块的实现用户信息管理基于SpringBoot的宠物咖啡馆平台的设计与实现的系统管理员可以管理用户，可以对用户信息添
    
                    
    • 
                    
  • Spring Cache sync属性
                        你这个代码我看不懂
Springspringjava后端
                        
    在SpringCache中，@Cacheable注解用于标记一个方法，使其返回值可以被缓存。sync属性是Spring4.3引入的一个新特性，用于控制缓存的同步行为。sync属性sync属性的默认值是false，表示异步缓存。如果将sync设置为true，则表示同步缓存。异步缓存（sync=false）当sync属性为false时，如果多个线程同时请求同一个缓存键，并且该键在缓存中不存在，所有线程
    
                    
    • 
                    
  • Java中的Lambda表达式详解
                        java面试跟我走
javapythonwindows
                        
    一、Lambda表达式概述Lambda表达式是Java8引入的一个新特性，它使得编写简洁、功能强大的代码变得更加容易。Lambda表达式允许以简洁的方式表示匿名函数，从而在Java中实现函数式编程。通过Lambda表达式，我们可以将函数作为参数传递给其他函数，或者作为结果返回。二、Lambda表达式的语法Lambda表达式的语法如下：(参数)->{函数体}其中，参数是可选的，可以有0个或多个参数。
    
                    
    • 
                    
  • Linux搭建Java环境之jdk1.8安装图文教程
                        yundashi168
Java教程阿里云教程
                        
    Linux的使用相信大家都要用到java吧！在使用java前我们得先安装jdk以及配置环境变量等工作；下面小编给大家分享关于Linux安装jdk的详细步骤：【Linux服务器远程连接工具】xshell6快捷下载，xftp6快捷下载温馨提示：xshell负责编写和执行Linux命令，就是大家都知道的命令行。xftp负责上传和下载文件。两款软件搭配使用。还有一款免费的国产的linux远程连接客户端—f
    
                    
    • 
                    
  • Mac安装配置jdk——jdk1.8，jdk11，jdk17
                        奋起的菜鸟想暴富
javamacosjava开发语言
                        
    我们日常工作中可能会在多个项目工程中来回切换，每个项目依赖的jdk版本也可能高低不同，这样会出现jdk版本高低的不兼容，工程代码编译不过，无法本地运行等问题。那么能不能在一台电脑上装多个版本的jdk呢？多个jdk版本是否可以灵活切换呢？答案是可以的！接下来就介绍Mac上的安装配置流程1、确认是否已经有jdk打开终端控制台，执行下面命令，查看是否有已下载好的jdk包➜~cd/Library/Java
    
                    
    • 
                    
  • vue3，从vue2迁移更改总结
                        梦里施
网页类vue.js
                        
    1.v-for中的Ref数组在Vue2中，在v-for里使用的refattribute会用ref数组填充相应的$refsproperty。当存在嵌套的v-for时，这种行为会变得不明确且效率低下。在Vue3中，这样的用法将不再在$ref中自动创建数组。要从单个绑定获取多个ref，请将ref绑定到一个更灵活的函数上(这是一个新特性)：setItemRef()2.异步组件现在，在Vue3中，由于函数式
    
                    
    • 
                    
  • CSS3新特性
                        FL1623863121
css3前端css
                        
    CSS3新特性CSS3是最新的CSS标准，旨在扩展CSS2.1。圆角通过border-radius属性可以给任何元素制作圆角。border-radius:所有四个边角border-*-*-radius属性的缩写。border-top-left-radius:定义了左上角的弧度。border-top-right-radius:定义了右上角的弧度。border-bottom-right-radius:
    
                    
    • 
                    
  • 计算机毕业设计 SSM高校网上报名系统 网上报名数据系统 会计网上报名系统Java
                        计算机程序老哥

                        
    作者主页：计算机毕业设计老哥有问题可以主页问我一、开发介绍1.1开发环境开发语言：Java数据库：MySQL系统架构：B/S后端：SSM(Spring+SpringMVC+Mybatis)前端：Vue工具：IDEA或者Eclipse，JDK1.8，Maven二、系统介绍2.1图片展示注册登录页面：登陆前端页面功能：首页、级别专业、系统论坛、系统公告、个人中心、后台管理、在线客服首页级别专业系统公告
    
                    
    • 
                    
  • JVM是什么？
                        .suki...
JVM1024程序员节
                        
    JVM是java虚拟机栈，用于运行java执行字节码文件的。是java实现跨平台的核心机制，因为它的目的是使用相同的字节码文件，在不同的操作系统运行的结果相同。一、java内存模型在JDK1.8之前，它是分为线程共享和线程私有的，在线程共享的部分分为堆区和方法区；在线程私有的部分分为jvm虚拟机栈、程序计数器、本地方法栈。在1.8之后，它是将方法区换为元空间。jvm虚拟机栈：是由一个个的栈帧组成，
    
                    
    • 
                    
  • 2024上学期--实验室学习计划
                        m0_66357705
javascript前端vue.js
                        
    阶段周次学习内容实践内容时间安排新增内容/重点基础巩固1-2周Java基础，多线程，TCP/IP网络编程相关练习和小的编程项目每天学习2小时，实践1小时Java20及以上版本新特性学习框架深入学习3-6周Spring，SpringBoot相关练习和小的编程项目每天学习3小时，实践1.5小时学习SpringCloud和微服务架构基础前端技术提升7-8周Vue2，Vue3相关练习和小的编程项目每天学习
    
                    
    • 
                    
  • springboot旅游管理系统的设计与实现
                        然然学长
springboot旅游java毕业设计后端
                        
    运行环境环境说明:开发语言:java框架:springboot，vueJDK版本:JDK1.8数据库:mysql5.7+(推荐5.7，8.0也可以)数据库工具:Navicat11+开发软件:idea/eclipse(推荐idea)Maven包:Maven3.3.9+系统实现登录模块的实现用户要想进入本系统，必须通过正确的用户名和密码，选择登录类型进行登录操作，在登录时系统会以用户名、密码和登录类型
    
                    
    • 
                                
  • mongodb3.03开启认证
                                    21jhf
mongodb
                                    
    下载了最新mongodb3.03版本，当使用--auth 参数命令行开启mongodb用户认证时遇到很多问题，现总结如下： 
（百度上搜到的基本都是老版本的，看到db.addUser的就是，请忽略） 
Windows下我做了一个bat文件，用来启动mongodb，命令行如下： 
mongod --dbpath db\data --port 27017 --directoryperdb --logp
    
                                
    • 
                                
  • 【Spark103】Task not serializable
                                    bit1129
Serializable
                                    
    Task not serializable是Spark开发过程最令人头疼的问题之一，这里记录下出现这个问题的两个实例，一个是自己遇到的，另一个是stackoverflow上看到。等有时间了再仔细探究出现Task not serialiazable的各种原因以及出现问题后如何快速定位问题的所在，至少目前阶段碰到此类问题，没有什么章法 
1. 
  
package spark.exampl
    
                                
    • 
                                
  • 你所熟知的 LRU(最近最少使用)
                                    dalan_123
java
                                    
    关于LRU这个名词在很多地方或听说，或使用，接下来看下lru缓存回收的实现 
1、大体的想法 
    a、查询出最近最晚使用的项 
    b、给最近的使用的项做标记 
通过使用链表就可以完成这两个操作，关于最近最少使用的项只需要返回链表的尾部；标记最近使用的项，只需要将该项移除并放置到头部，那么难点就出现 你如何能够快速在链表定位对应的该项？ 
这时候多
    
                                
    • 
                                
  • Javascript 跨域
                                    周凡杨
JavaScriptjsonp跨域cross-domain
                                    
      
                                 
    
                                
    • 
                                
  • linux下安装apache服务器
                                    g21121
apache
                                    
    安装apache  
下载windows版本apache，下载地址：http://httpd.apache.org/download.cgi 
   1.windows下安装apache   
Windows下安装apache比较简单，注意选择路径和端口即可，这里就不再赘述了。  2.linux下安装apache：  
下载之后上传到linux的相关目录，这里指定为/home/apach
    
                                
    • 
                                
  • FineReport的JS编辑框和URL地址栏语法简介
                                    老A不折腾
finereportweb报表报表软件语法总结
                                    
      JS编辑框： 
1.FineReport的js。 
作为一款BS产品，browser端的JavaScript是必不可少的。 
FineReport中的js是已经调用了finereport.js的。 
大家知道，预览报表时，报表servlet会将cpt模板转为html，在这个html的head头部中会引入FineReport的js，这个finereport.js中包含了许多内置的fun
    
                                
    • 
                                
  • 根据STATUS信息对MySQL进行优化
                                    墙头上一根草
status
                                    
    mysql  查看当前正在执行的操作，即正在执行的sql语句的方法为: 
     show processlist 命令 
  
mysql> show global status;可以列出MySQL服务器运行各种状态值，我个人较喜欢的用法是show status like '查询值%';一、慢查询mysql> show variab
    
                                
    • 
                                
  • 我的spring学习笔记7-Spring的Bean配置文件给Bean定义别名
                                    aijuans
Spring 3
                                    
    本文介绍如何给Spring的Bean配置文件的Bean定义别名？ 
 
原始的 
 
 
<bean id="business" class="onlyfun.caterpillar.device.Business">
    <property name="writer">
        <ref b
    
                                
    • 
                                
  • 高性能mysql 之 性能剖析
                                    annan211
性能mysqlmysql 性能剖析剖析
                                    
    

1 定义性能优化
  mysql服务器性能，此处定义为 响应时间。
  在解释性能优化之前，先来消除一个误解，很多人认为，性能优化就是降低cpu的利用率或者减少对资源的使用。
  这是一个陷阱。
  资源时用来消耗并用来工作的，所以有时候消耗更多的资源能够加快查询速度，保持cpu忙绿，这是必要的。很多时候发现
  编译进了新版本的InnoDB之后，cpu利用率上升的很厉害，这并不
    
                                
    • 
                                
  • 主外键和索引唯一性约束
                                    百合不是茶
索引唯一性约束主外键约束联机删除
                                    
    目标;第一步;创建两张表 用户表和文章表 
        第二步;发表文章 
  
  
  1,建表; 
    ---用户表 BlogUsers
    --userID唯一的
    --userName
    --pwd
    --sex
        

    create 
    
                                
    • 
                                
  • 线程的调度
                                    bijian1013
java多线程thread线程的调度java多线程
                                    
    1.       Java提供一个线程调度程序来监控程序中启动后进入可运行状态的所有线程。线程调度程序按照线程的优先级决定应调度哪些线程来执行。 
  
2.       多数线程的调度是抢占式的（即我想中断程序运行就中断，不需要和将被中断的程序协商） 
a) 
    
                                
    • 
                                
  • 查看日志常用命令
                                    bijian1013
linux命令unix
                                    
    一.日志查找方法，可以用通配符查某台主机上的所有服务器grep "关键字" /wls/applogs/custom-*/error.log 
  
二.查看日志常用命令1.grep '关键字' error.log：在error.log中搜索'关键字'2.grep -C10 '关键字' error.log：显示关键字前后10行记录3.grep '关键字' error.l
    
                                
    • 
                                
  • 【持久化框架MyBatis3一】MyBatis版HelloWorld
                                    bit1129
helloworld
                                    
    MyBatis这个系列的文章，主要参考《Java Persistence with MyBatis 3》。 
  样例数据 
本文以MySQL数据库为例，建立一个STUDENTS表，插入两条数据，然后进行单表的增删改查 
  
  
CREATE TABLE STUDENTS
(
stud_id int(11) NOT NULL AUTO_INCREMENT,

    
                                
    • 
                                
  • 【Hadoop十五】Hadoop Counter
                                    bit1129
hadoop
                                    
      
 1. 只有Map任务的Map Reduce Job  
	File System Counters
		FILE: Number of bytes read=3629530
		FILE: Number of bytes written=98312
		FILE: Number of read operations=0
		FILE: Number of lar
    
                                
    • 
                                
  • 解决Tomcat数据连接池无法释放
                                    ronin47
tomcat 连接池　优化
                                    
     
 近段时间，公司的检测中心报表系统(SMC)的开发人员时不时找到我，说用户老是出现无法登录的情况。前些日子因为手头上 有Jboss集群的测试工作，发现用户不能登录时，都是在Tomcat中将这个项目Reload一下就好了，不过只是治标而已，因为大概几个小时之后又会 再次出现无法登录的情况。 
  
今天上午，开发人员小毛又找到我，要我协助将这个问题根治一下，拖太久用户难保不投诉。 
简单分析了一
    
                                
    • 
                                
  • java-75-二叉树两结点的最低共同父结点
                                    bylijinnan
java
                                    
    
import java.util.LinkedList;
import java.util.List;

import ljn.help.*;
public class BTreeLowestParentOfTwoNodes {

	public static void main(String[] args) {
		/*
		 * node data is stored in
    
                                
    • 
                                
  • 行业垂直搜索引擎网页抓取项目
                                    carlwu
LuceneNutchHeritrixSolr
                                    
    公司有一个搜索引擎项目，希望各路高人有空来帮忙指导，谢谢！ 
这是详细需求： 
（1） 通过提供的网站地址(大概100-200个网站)，网页抓取程序能不断抓取网页和其它类型的文件（如Excel、PDF、Word、ppt及zip类型），并且程序能够根据事先提供的规则，过滤掉不相干的下载内容。 
（2） 程序能够搜索这些抓取的内容，并能对这些抓取文件按照油田名进行分类，然后放到服务器不同的目录中。 

    
                                
    • 
                                
  • [通讯与服务]在总带宽资源没有大幅增加之前,不适宜大幅度降低资费
                                    comsci
资源
                                    
     
 
      降低通讯服务资费，就意味着有更多的用户进入，就意味着通讯服务提供商要接待和服务更多的用户，在总体运维成本没有由于技术升级而大幅下降的情况下，这种降低资费的行为将导致每个用户的平均带宽不断下降，而享受到的服务质量也在下降，这对用户和服务商都是不利的。。。。。。。。 
 
 
    &nbs
    
                                
    • 
                                
  • Java时区转换及时间格式
                                    Cwind
java
                                    
    本文介绍Java API 中 Date, Calendar, TimeZone和DateFormat的使用，以及不同时区时间相互转化的方法和原理。 
  
问题描述： 
向处于不同时区的服务器发请求时需要考虑时区转换的问题。譬如，服务器位于东八区（北京时间，GMT+8:00），而身处东四区的用户想要查询当天的销售记录。则需把东四区的“今天”这个时间范围转换为服务器所在时区的时间范围。 

    
                                
    • 
                                
  • readonly,只读，不可用
                                    dashuaifu
jsjspdisablereadOnlyreadOnly
                                    
    readOnly 和 readonly 不同，在做js开发时一定要注意函数大小写和jsp黄线的警告！！！我就经历过这么一件事： 
使用readOnly在某些浏览器或同一浏览器不同版本有的可以实现“只读”功能，有的就不行，而且函数readOnly有黄线警告！！！就这样被折磨了不短时间！！！（期间使用过disable函数，但是发现disable函数之后后台接收不到前台的的数据！！！） 
  
    
                                
    • 
                                
  • LABjs、RequireJS、SeaJS 介绍
                                    dcj3sjt126com
jsWeb
                                    
    LABjs 的核心是 LAB（Loading and Blocking）：Loading 指异步并行加载，Blocking 是指同步等待执行。LABjs 通过优雅的语法（script 和 wait）实现了这两大特性，核心价值是性能优化。LABjs 是一个文件加载器。RequireJS 和 SeaJS 则是模块加载器，倡导的是一种模块化开发理念，核心价值是让 JavaScript 的模块化开发变得更
    
                                
    • 
                                
  • [应用结构]入口脚本
                                    dcj3sjt126com
PHPyii2
                                    
    入口脚本 
入口脚本是应用启动流程中的第一环，一个应用（不管是网页应用还是控制台应用）只有一个入口脚本。终端用户的请求通过入口脚本实例化应用并将将请求转发到应用。 
Web 应用的入口脚本必须放在终端用户能够访问的目录下，通常命名为 index.php，也可以使用 Web 服务器能定位到的其他名称。 
控制台应用的入口脚本一般在应用根目录下命名为 yii（后缀为.php），该文
    
                                
    • 
                                
  • haoop shell命令
                                    eksliang
hadoophadoop shell
                                    
     
 cat 
 chgrp 
 chmod 
 chown 
 copyFromLocal 
 copyToLocal 
 cp 
 du 
 dus 
 expunge 
 get 
 getmerge 
 ls 
 lsr 
 mkdir 
 movefromLocal 
 mv 
 put 
 rm 
 rmr 
 setrep 
 stat 
 tail 
 test 
 text 
 
    
                                
    • 
                                
  • MultiStateView不同的状态下显示不同的界面
                                    gundumw100
android
                                    
    只要将指定的view放在该控件里面，可以该view在不同的状态下显示不同的界面，这对ListView很有用，比如加载界面，空白界面，错误界面。而且这些见面由你指定布局，非常灵活。 
 
PS：ListView虽然可以设置一个EmptyView，但使用起来不方便，不灵活，有点累赘。 
 
 

<com.kennyc.view.MultiStateView xmlns:android=&qu
    
                                
    • 
                                
  • jQuery实现页面内锚点平滑跳转
                                    ini
JavaScripthtmljqueryhtml5css
                                    
    平时我们做导航滚动到内容都是通过锚点来做，刷的一下就直接跳到内容了，没有一丝的滚动效果，而且 url 链接最后会有“小尾巴”，就像#keleyi，今天我就介绍一款 jquery 做的滚动的特效，既可以设置滚动速度，又可以在 url 链接上没有“小尾巴”。 
  
效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/37.htmHTML文件代码： 
&
    
                                
    • 
                                
  • kafka offset迁移
                                    kane_xie
kafka
                                    
    在早前的kafka版本中（0.8.0），offset是被存储在zookeeper中的。 
  
到当前版本（0.8.2）为止，kafka同时支持offset存储在zookeeper和offset manager（broker）中。 
  
从官方的说明来看，未来offset的zookeeper存储将会被弃用。因此现有的基于kafka的项目如果今后计划保持更新的话，可以考虑在合适
    
                                
    • 
                                
  • android > 搭建 cordova 环境
                                    mft8899
android
                                    
      
1 , 安装 node.js   
     http://nodejs.org 
     
node -v   查看版本 
  
2, 安装 npm 
  
可以先从  https://github.com/isaacs/npm/tags  下载 源码 解压到
    
                                
    • 
                                
  • java封装的比较器，比较是否全相同，获取不同字段名字
                                    qifeifei

                                    
     非常实用的java比较器，贴上代码： 
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;

i
    
                                
    • 
                                
  • 记录一些函数用法
                                    .Aky.
位运算PHP数据库函数IP
                                    
    高手们照旧忽略。 
想弄个全天朝IP段数据库，找了个今天最新更新的国内所有运营商IP段，copy到文件，用文件函数，字符串函数把玩下。分割出startIp和endIp这样格式写入.txt文件，直接用phpmyadmin导入.csv文件的形式导入。（生命在于折腾，也许你们觉得我傻X，直接下载人家弄好的导入不就可以，做自己的菜鸟，让别人去说吧） 
 
当然用到了ip2long()函数把字符串转为整型数
    
                                
    • 
                                
  • sublime text 3 rust
                                    wudixiaotie
Sublime Text
                                    
    1.sublime text 3 => install package => Rust 
2.cd ~/.config/sublime-text-3/Packages 
3.mkdir rust 
4.git clone https://github.com/sp0/rust-style 
5.cd rust-style 
6.cargo build --release 
7.ctrl
    
                                
    •