Category Archives: Java

Java基本语法的几个笔记

1 需要注意的点

1.1 运算赋值操作

  1. 复合赋值运算中(如:+=、-=等),隐含了类型强制转换。如:
    byte b = 126;
    // 按常理2是int型,byte + int 结果应该是int,但这里会强转为byte
    b += 2;  // 结果会溢出
    System.out.println(b); // -128
    
  2. 三目运算不能单独存在,运算结果必须要有“接收方”
    OperationDemo.java:10: 错误: 不是语句
                   a > b ? a : b;
                         ^
    1 个错误
    
  3. 整数类型中byte、short、int、long四种的前三种在运算时都会先转换为int类型;
    byte a = 10;
    byte b = 20;
    // 事实上是byte = int + int,所以编译时会报错
    byte ret = a + b;
    
    OperationDemo.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
                   byte ret = a + b;
                                ^
    1 个错误
    
  4. 如果表达式的右边为常量,编译时会先将表达的进行计算,用结果替换原来的表达式,如:
    // 上述示例中ret = a + b,表达式右边是int型,左边是byte,有转换失真的风险所以编译会报错;
    // 但如果右边是常量则不会,byte ret = 10 + 20类似直接写byte ret = 30;
    byte ret = 10 + 20;
    

1.2 函数与方法

  1. 方法重载中如果返回值类型不一样,不构成方法重载。(想想看,返回值是可以强制类型转换的,那么编译器到底该给哪个方法呢?所以此处有歧异)
    public static int sum(int a, int b) {
       return a + b;
    }
    // 编译报错,方法重名了,仅返回值类型不同不构成方法重载
    public static float sum(int a, int b) {
       return (float) (a + b);
    }
    

1.3 数组

  1. 数组初始化的几种方式,主要有静态初始化(指定值)与动态初始化(指定长度);
  • 所谓的静态与动态区别是即时指定长度还是直接赋值;
  • Java中指定值有两种方式,一种是类型前缀,一种不加(所谓的标准格式与省略格式);
  • 在其他高级语言中如C++,静态初始化不能拆开写(即省略格式),但Java标准格式可以;
  • 动态初始化数组时,内存中全部写0,即int为0、float为0.0、对象为null、char为\u0000
    // 动态初始化,在创建数组时指定数组长度
    int[] array1 = new int[10];
    System.out.println(array1);
    int[] array2 = new int[10];
    System.out.println(array2);
    
    // 静态初始化,创建数组时直接以数据长度为准
    int[] array3 = new int[] {1, 2, 3, 4};
    System.out.println(array3);
    int[] array4 = {1, 2, 3, 4};
    System.out.println(array4);
    
    // 初始化可以先定义变量再赋值,但有一种情况例外
    int[] array5;
    array5 = new int[10];
    int[] array6;
    array6 = new int[] {1, 2, 3, 4};
    int[] array7;
    array7 = {1, 2, 3, 4}; // 注意:这种情况是非法的,编译报错
    

2 相关总结

2.1 类与对象

[……]

继续阅读

斗地主发牌的简单实现

ArrayList版

package com.yusian.poker;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class PokerDemo {
    public static void main(String[] args) {
        String[] colors = {"♠️", "♥️", "♣️", "♦️"};
        String[] numbers = {"2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3"};
        ArrayList<String> poker = new ArrayList<>();
        poker.add("大王");
        poker.add("小王");
        for (String color : colors) {
            for (String number : numbers) {
                poker.add(number + color);
            }
        }
        System.out.println(poker);
        // 打乱顺序
        Collections.shuffle(poker);
        System.out.println(poker);
        ArrayList<String> player1 = new ArrayList<>();
        ArrayList<String> player2 = new ArrayList<>();
        ArrayList<String> player3 = new ArrayList<>();
        ArrayList<String> remain = new ArrayList<>();
        for (int i = 0; i < poker.size(); i++) {
            String p = poker.get(i);
            if (i >= 51) {
                remain.add(p);
            } else if (i % 3 == 0) {
                player1.add(p);
            } else if (i % 3 == 1) {
                player2.add(p);
            } else {
                player3.add(p);
            }
        }
        // 排序
        player1.sort(Comparator.comparingInt((String o) -> o.charAt(0)));
        player2.sort(Comparator.comparingInt((String o) -> o.charAt(0)));
        player3.sort(Comparator.comparingInt((String o) -> o.charAt(0)));
        System.out.println("------------------");
        System.out.println("player1:" + player1);
        System.out.println("player2:" + player2);
        System.out.println("player3:" + player3);
        System.out.println("底牌:" + remain);
    }
}
[大王, 小王, 2♠️, A♠️, K♠️, Q♠️, J♠️, 10♠️, 9♠️, 8♠️, 7♠️, 6♠️, 5♠️, 4♠️, 3♠️, 2♥️, A♥️, K♥️, Q♥️, J♥️, 10♥️, 9♥️, 8♥️, 7♥️, 6♥️, 5♥️, 4♥️, 3♥️, 2♣️, A♣️, K♣️, Q♣️, J♣️, 10♣️, 9♣️, 8♣️, 7♣️, 6♣️, 5♣️, 4♣️, 3♣️, 2♦️, A♦️, K♦️, Q♦️, J♦️, 10♦️, 9♦️, 8♦️, 7♦️, 6♦️, 5♦️, 4♦️, 3♦️]
[2♠️, J♣️, 4♦️, 5♠️, 9♠️, Q♠️, 6♠️, 7♠️, Q♦️, 3♦️, 2♣️, 4♣️, 10♦️, 9♦️, 3♥️, 7♦️, A♥️, 3♠️, 5♥️, K♥️, 9♥️, 8♠️, K♦️, A♦️, 5♣️, J♥️, K♠️, 2♦️, 6♣️, A♣️, 8♦️, 6♥️, 9♣️, 4♠️, 10♥️, 10♣️, 8♥️, 大王, J♠️, 5♦️, A♠️, Q♥️, 6♦️, 4♥️, 8♣️, 3♣️, K♣️, 2♥️, Q♣️, 7♥️, 10♠️, 7♣️, J♦️, 小王]
------------------
player1:[10♦️, 2♠️, 2♦️, 3♦️, 3♣️, 4♠️, 5♠️, 5♥️, 5♣️, 5♦️, 6♠️, 6♦️, 7♦️, 8♠️, 8♦️, 8♥️, Q♣️]
player2:[10♥️, 2♣️, 4♥️, 6♣️, 6♥️, 7♠️, 7♥️, 9♠️, 9♦️, A♥️, A♠️, J♣️, J♥️, K♥️, K♦️, K♣️, 大王]
player3:[10♣️, 10♠️, 2♥️, 3♥️, 3♠️, 4♦️, 4♣️, 8♣️, 9♥️, 9♣️, A♦️, A♣️, J♠️, K♠️, Q♠️, Q♦️, Q♥️]
底牌:[7♣️, J♦️, 小王]

HashMap版
[……]

继续阅读

正则表达式中原子组的基本使用

什么是原子组

简单一点讲,原子组就是正则表达式中的小括号()及所包括的内容

一个简单的示例

let date = '今天是2020-09/29';
// 日期分隔符有/或-,如是分开写,会匹配出前后不一致的数据,比如2020-09/29
let reg = /\d{4}[\/\-]\d{2}[[......]

继续阅读