22. Java 正则表达式

发表于 2017-01-24 更新于 2022-10-06 分类于语言-Java ，基础

正则表达式（regular expression）用于指定字符串的模式，你可以在任何需要定位匹配某种特定模式的字符串的情况下使用正则表达式。

正则表达式语法

正则表达式语法(续)

预定义的字符类名字

大部分字符都可以与它们自身匹配
. 符号可以匹配任何字符（有可能不包括行终止符，这取决于标志的设置）。
使用 \ 作为转义字符，例如，\\. 匹配句号而 \\\ 匹配反斜线。
^ 和 $ 分别匹配一行的开头和结尾。
如果 X 和 Y 是正则表达式，那么 XY 表示“任何 X 的匹配后面跟随 Y 的匹配”，X|Y 表示“任何 X 或 Y 的匹配”。
你可以将量词运用到表达式 X：X+（1 个或多个）、X* （0 个或多个）与 X ？（0 个或 1 个）。
默认情况下，量词要匹配能够使整个匹配成功的最大可能的重复次数。你可以修改这种行为，方法是使用后缀 ?（使用勉强或吝啬匹配，也就是匹配最小的重复次数）或使用后缀 +（使用占有或贪婪匹配，也就是即使让整个匹配失败，也要匹配最大的重复次数）。
例如，字符串 cab 匹配 [a-z]*ab，但是不匹配 [a-z]*+ab。在第一种情况中，表达式 [a-z]* 只匹配字符 c，使得字符 ab 匹配该模式的剩余部分；但是贪婪版本[a-z]*+ 将匹配字符 cab，模式的剩余部分将无法匹配。
我们使用群组来定义子表达式，其中群组用括号 () 括起来。例如，([±]?)([0-9]+)。然后你可以询问模式匹配器，让其返回每个组的匹配，或者用 \n 来引用某个群组，其中 n 是群组号（从 \1 开始）。
捕获组可以通过从左到右计算其开括号来编号。

阅读全文 »

23. Java 图形化编程

发表于 2017-01-24 更新于 2022-10-06 分类于语言-Java ，基础

图形用户界面（Graphical User Interface，简称 GUI）编程对于某种语言来说非常重要。Java 的应用主要方向是基于 Web 浏览器的应用，用户界面主要是 HTML、CSS 和 JavaScript 等基于 Web 的技术，这些介绍要到 Java EE 阶段才能学习到。

而本章介绍的 Java 图形用户界面技术是基于 Java SE 的 Swing，事实上它们在实际应用中使用不多，因此本章的内容只做了解。

Java 图形用户界面技术

1. AWT
AWT（Abstract Window Toolkit）是抽象窗口工具包，AWT 是 Java 程序提供的建立图形用户界面最基础的工具集。AWT 支持图形用户界面编程的功能包括：用户界面组件（控件）、事件处理模型、图形图像处理（形状和颜色）、字体、布局管理器和本地平台的剪贴板来进行剪切和粘贴等。AWT 是 Applet 和 Swing 技术的基础。
AWT在实际的运行过程中是调用所在平台的图形系统，因此同样一段AWT程序在不同的操作系统平台下运行所看到的样式不同的。
2. Applet
Applet 称为 Java 小应用程序，Applet 基础是 AWT，但它主要嵌入到 HTML 代码中，由浏览器加载和运行，由于存在安全隐患和运行速度慢等问题，已经很少使用了。
3. Swing
Swing 是 Java 主要的图形用户界面技术，Swing 提供跨平台的界面风格，用户可以自定义 Swing 的界面风格。Swing 提供了比 AWT 更完整的组件，引入了许多新的特性。Swing API 是围绕着实现 AWT 各个部分的 API 构筑的。Swing 是由100% 纯 Java 实现的，Swing 组件没有本地代码，不依赖操作系统的支持，这是它与AWT组件的最大区别。本章重点介绍Swing技术。
4. JavaFX
JavaFX 是开发丰富互联网应用程序（Rich Internet Application，缩写RIA）的图形用户界面技术，JavaFX 期望能够在桌面应用的开发领域与 Adobe 公司的 AIR、微软公司的 Silverlight 相竞争。传统的互联网应用程序基于 Web 的，客户端是浏览器。而丰富互联网应用程序试图打造自己的客户端，替代浏览器。

Swing 技术基础

AWT 是 Swing 的基础，Swing 事件处理和布局管理都是依赖于 AWT，AWT 内容来自 java.awt 包，Swing 内容来自 javax.swing 包。AWT 和 Swing 作为图形用户界面技术包括了 4 个主要的概念：组件（Component）、容器（Container）、事件处理和布局管理器（LayoutManager），下面将围绕这些概念展开。

阅读全文 »

Java 8 的 Stream 操作

发表于 2017-01-24 更新于 2022-10-06 分类于语言-Java ，基础

方法引用

方法引用分为三种，方法引用通过一对双冒号 :: 来表示，方法引用是一种函数式接口的另一种书写方式

静态方法引用，通过类名::静态方法名，如 Integer::parseInt
实例方法引用，通过实例对象::实例方法，如 str::substring
类名::实例方法名, 如 String::substring
构造方法引用，通过类名::new，如 User::new

第三点: 若 Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式：类名::实例方法名

类名::方法名，相当于对这个方法闭包的引用，类似 js 中的一个 function。比如：

public static void main(String[] args) {
    Consumer<String> printStrConsumer = DoubleColon::printStr;
    printStrConsumer.accept("printStrConsumer");

    Consumer<DoubleColon> toUpperConsumer = DoubleColon::toUpper;
    toUpperConsumer.accept(new DoubleColon());

    BiConsumer<DoubleColon,String> toLowerConsumer = DoubleColon::toLower;
    toLowerConsumer.accept(new DoubleColon(),"toLowerConsumer");

    BiFunction<DoubleColon,String,Integer> toIntFunction = DoubleColon::toInt;
    int i = toIntFunction.apply(new DoubleColon(),"toInt");
}

static class DoubleColon {

    public static void printStr(String str) {
        System.out.println("printStr : " + str);
    }

    public void toUpper(){
        System.out.println("toUpper : " + this.toString());
    }

    public void toLower(String str){
        System.out.println("toLower : " + str);
    }

    public int toInt(String str){
        System.out.println("toInt : " + str);
        return 1;
    }
}

用::提取的函数，最主要的区别在于静态与非静态方法，非静态方法比静态方法多一个参数，就是被调用的实例。

// 使用双冒号::来构造非静态函数引用
String content = "Hello JDK 8";

// public String substring(int beginIndex)
// 写法一: 对象::非静态方法
Function<Integer, String> func = content::substring;
String result = func.apply(1);
System.out.println(result);

// 写法二:
IntFunction<String> intFunc = content::substring;
result = intFunc.apply(1);
System.out.println(result);

// 写法三: String::非静态方法
BiFunction<String,Integer,String> lala = String::substring;
String s = lala.apply(content, 1);
System.out.println(s);

// public String toUpperCase()
// 写法一: 函数引用也是一种函数式接口，所以也可以将函数引用作为方法的参数
Function<String, String> func2 = String::toUpperCase;
result = func2.apply("lalala");
System.out.println(result);

// 写法二: 可以改写成Supplier: 入参void, 返回值String
Supplier<String> supplier = "alalal"::toUpperCase;
result = supplier.get();
System.out.println(result);

数组引用

// 传统Lambda实现
IntFunction<int[]> function = (i) -> new int[i];
int[] apply = function.apply(5);
System.out.println(apply.length); // 5

// 数组类型引用实现
function = int[]::new;
apply = function.apply(10);
System.out.println(apply.length); // 10

Optional 的用法

// Optional 类已经成为 Java 8 类库的一部分，在 Guava 中早就有了，可能 Oracle 是直接拿来使用了
// Optional 用来解决空指针异常，使代码更加严谨，防止因为空指针 NullPointerException 对代码造成影响
String msg = "hello";
Optional<String> optional = Optional.of(msg);
// 判断是否有值，不为空
boolean present = optional.isPresent();
// 如果有值，则返回值，如果等于空则抛异常
String value = optional.get();
// 如果为空，返回 else 指定的值
String hi = optional.orElse("hi");
// 如果值不为空，就执行 Lambda 表达式
optional.ifPresent(opt -> System.out.println(opt));

Stream 的操作

有些 Stream 可以转成集合，比如前面提到 toList,生成了 java.util.List 类的实例。当然了，还有还有 toSet 和toCollection，分别生成 Set 和 Collection 类的实例。

final List<String> list = Arrays.asList("jack", "mary", "lucy");

// 过滤 + 输出
System.out.println("过滤 + 输出: ");
Stream<String> stream = list.stream();
stream.filter(item -> !item.equals("zhangsan"))
    .filter(item -> !item.equals("wangwu"))
    .forEach(item -> System.out.println(item));

// 限制为2
System.out.println("limit(2): ");
list.stream().limit(2).forEach(System.out::println);

// 排序
System.out.println("排序: ");
list.stream().sorted((o1, o2) -> o1.compareTo(o2)).forEach(System.out::println);

// 取出最大值
System.out.println("max: ");
String result = list.stream().max((o1, o2) -> o1.compareTo(o2)).orElse("error");
System.out.println(result);


// toList
System.out.println("toList: ");
List<Integer> collectList = Stream.of(1, 2, 3, 4)
        .collect(Collectors.toList());
System.out.println("collectList: " + collectList);
// 打印结果
// collectList: [1, 2, 3, 4]

// toSet
System.out.println("toSet: ");
Set<Integer> collectSet = Stream.of(1, 2, 3, 4)
        .collect(Collectors.toSet());
System.out.println("collectSet: " + collectSet);
// 打印结果
// collectSet: [1, 2, 3, 4]

list 转 map(通过 stream)

List<Person> list = new ArrayList<>();
list.add(new Person(1, "mary"));
list.add(new Person(2, "lucy"));

Map<Integer, Person> map = list.stream().collect(Collectors.toMap(Person::getId, Function.identity()));
System.out.println(map);
// 输出: {1=Main3$Person@42f30e0a, 2=Main3$Person@24273305}

Map<Integer, String> map2 = list.stream().collect(Collectors.toMap(Person::getId, Person::getName));
System.out.println(map2);
// 输出: {1=mary, 2=lucy}

分割数据块

Map<Boolean, List<Integer>> map = Stream.of(1, 2, 3, 4)
        .collect(Collectors.partitioningBy(item -> item > 2));
    System.out.println(map);

// 输出: {false=[1, 2], true=[3, 4]}

函数的返回值只能将数据分为两组也就是 ture 和 false 两组数据。

groupingBy 数据块分组

数据分组是一种更自然的分割数据操作，与将数据分成 true 和 false 两部分不同，可以使用任意值对数据分组。

groupingBy 是都集合进行分组，分组之后的结果形如 Map<key,List>。其中，key 是进行分组的字段类型，比如按 Ussr 类中的 type（用户类型：1、2、3、4）进行分组，type的类型为Integer，分组之后的Map的key类型就是Integer。并且最多会分成四组，所以最后的结果即 Map<Integer,List>。
假设我们想用户类型为 1 的集合，首先先进行分组，如：

1	Map<Integer,List<User>> userMap = allUserList.parallelStream().collect(Collectors.groupingBy(User::getType));

接下来直接从 Map 中 get(1) 即可，如：List<User> userList = userMap.get(1);

groupingBy 与 partitioningBy 之间的坑

必须要提的一点是：在进行 get 时，groupingBy 分组若 key 不存在则返回 null，partitioningBy 则会返回空数组，groupingBy 分组注意判空。
stream 处理集合的效率并不一定比迭代器高，如果不要求顺序可以使用 parallelStream 进行并行流的处理。

根据俩个字段进行分组

1 2	Map<Integer, Map<BigDecimal, List<User>>> collect = userList.stream().filter(Objects::nonNull) .collect(Collectors.groupingBy(User::getAge, Collectors.groupingBy(User::getMoney)));

复杂分组

1
2

Map<Integer, Map<BigDecimal, List<Long>>> collect = userList.stream().filter(Objects::nonNull)
        .collect(Collectors.groupingBy(User::getAge, Collectors.groupingBy(User::getMoney, Collectors.mapping(User::getId, Collectors.toList()))));

collect

Collectors.joining 收集 Stream 中的值，该方法可以方便地将 Stream 得到一个字符串。joining 函数接受三个参数，分别表示允（用以分隔元素）、前缀和后缀。

String strJoin = Stream.of("1", "2", "3", "4")
        .collect(Collectors.joining(",", "[", "]"));
System.out.println("strJoin: " + strJoin);
// 打印结果
// strJoin: [1,2,3,4]

distinct

去重

limit

limit方法可以对流进行截取，只取用前n个。

peek

流由三部分组成：数据源、零个或多个中间操作以及零个或一个终端操作。

peek() 是一个中间操作，由于是惰性，所以如果没有对管道应用终端操作则不会执行。

peek() 的 Javadoc 页面说：“这个方法的存在主要是为了支持调试，如果希望在元素流过管道中的某个点时看到它们的值”。
最重要的是， peek() 在另一种情况下很有用：想要改变元素的内部状态时。例如，假设想在打印之前将所有用户名转换为小写。

举例

@Test
public void test(){
    List<String> collect = Stream.of("one", "two", "three", "four")
            .filter(e -> e.length() > 3)
            .peek(e -> System.out.println("过滤值: " + e))
            .map(String::toUpperCase)
            .peek(e -> System.out.println("映射值: " + e))
            .collect(Collectors.toList());
    System.out.println(collect);
}

skip

如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流

sorted 排序

stream 中有两个 sorted 方法：

一个无参的方法 Stream<T> sorted();查看它的实现类，往里进，发现它默认使用的是自然排序 compareTo。
一个有参的方法 Stream<T> sorted(Comparator<? super T> comparator); 该方法需要传一个比较器参数。

默认为升序
userList = userList.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());

改为降序

userList = userList.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());

多条件排序

userList = userList.stream().sorted(Comparator.comparing(User::getAge).thenComparing(User::getId)).collect(Collectors.toList());

应用：进行分页

final TableDataInfo dataTable = getDataTable(resultList);
final int pageSize = (query.getPageSize() != null && query.getPageSize() > 0) ? query.getPageSize() : 8;
final int pageNum = (query.getPageNum() != null && query.getPageNum() > 0) ? query.getPageNum() : 0;
dataTable.setRows(resultList.stream().skip((long) (pageNum - 1) * pageSize).limit(pageSize).
        collect(Collectors.toList()));

遇到过的问题

Java8 流处理过程进行 toMap 规约处理时的 java.util.stream.Collectors.lambda$throwingMerger$0(Collectors.java:133) 异常

解决方法：规约处理时进行冲突兼容处理，即出现冲突时进行取值选择

冲突处理选择方法，在 toMap(key, value, (v1,v2) -> v1)中添加冲突时选值参数“（v1, v2）-> v1”表示出现 key 冲突时取第一次出现的 key 的值,，“（v1, v2）-> v2” 表示出现 key 冲突时取最后一次出现的 key 的值，在实际中根据自己的实际情况取值。

1
2
3

Map<String, Integer> nameAgeMap = employList
  .stream()
  .collect(Collectors.toMap(Employee :: getName, Employee :: getAge, (v1, v2) -> v1));

参考

JDK1.8 新特性(三): 方法引用 ::和 Optional
https://blog.csdn.net/vbirdbest/article/details/80207673

https://blog.csdn.net/IO_Field/article/details/54971761
Java 8 系列之 Stream 的基本语法详解

Java8 新特性 Stream 使用心得之：groupingBy 与 partitioningBy_G_axis 的博客-CSDN博客
https://blog.csdn.net/V_Axis/article/details/86095053

这可能是史上最好的 Java8 新特性 Stream 流教程 - osc_bnuaa5jy 的个人空间 - OSCHINA
https://my.oschina.net/u/4271175/blog/3265285

Java8 中使用 stream 进行分组统计和普通实现的分组统计的性能对比_冯立彬的博客-CSDN 博客_java stream 分组统计
https://blog.csdn.net/fenglibing/article/details/80238310

Java 常用工具类使用

发表于 2017-01-24 更新于 2022-10-06 分类于语言-Java ，基础

Random 类

让系统产生随机数使用

产生 0~9 的随机数 (int)(Math.random()*10);
产生 0~10 的随机数为 (int)(Math.random()*(11));
产生 0~999 的随机数 (int)(Math.random()*1000);

产生 1~10 的随机数为 (int)(Math.random()*10) + 1;

生成从 0 到 n-1 的随机整数即返回值[0,n) (int)(Math.random()*(n+1);
生成从 0 到 n 的随机整数即返回值[0,n] (int)(Math.random()*(n+1);

生成从 a 到 b 的随机整数即返回值[a,b]
a + (int)(Math.random()*(b-a+1));

其实 Math 的 random 方法用的就是 util 包中的 Random 类。因此可以 Random.nextDouble() 替换 Math.random(), 但是这样说不太准确。

阅读全文 »

Java 总结

发表于 2017-01-24 更新于 2022-10-06 分类于语言-Java ，基础

标准输入输出流

字符输入: char c = (char)System.in.read();

字符串输入:

1 2	BufferedReader buf = new BufferedReader(new InputStreamReader(System.in)); String str = buf.readLine();

使用 System.out 输出

(标准输出流 System.out )提供的如下方法

print()方法：实现不换行的数据输出；
println()方法：与上面方法的差别是输出数据后将换行。
printf()方法：带格式描述的数据输出。该方法包含两个参数，第一个参数中给出输出格式的描述，第 2 个参数为输出数据，其中，输出格式描述字符串中需要安排与输出数据对应的格式符。常用格式符包括：%d 代表十进制数；%f 代表浮点数；%e 代表科学表示法的指数位数；%n 代表换行符；%x 代表十六进制数；%s 代表字符串。

阅读全文 »