拼图小游戏

最新推荐文章于 2024-07-06 16:47:20 发布

lazy_girl_666

最新推荐文章于 2024-07-06 16:47:20 发布

阅读量754

点赞数 23

文章标签： java 算法开发语言

本文链接：https://blog.csdn.net/lazy_girl_666/article/details/139355366

版权

GUI（指采用图形化的方式显示操作界面）

AWT包 Swing包（常用）

事件

事件源：按钮图片窗体...

事件：某些操作

如：鼠标单击，鼠标划入...

绑定监听：当事件源上发生了某个事件，则执行某段代码

KeyListener MouseListener ActionListener

Math

常用方法：

public static int abs(int a);//求绝对值

public static double ceil(double a);//向上取整

public static double floor(double a);//向下取整

public static int round(float a);//四舍五入

public static int max(int a,int b);

public static double pow(double a,double b);//返回a的b次幂的值

public static double random();//返回值为double的随机值，范围为[0,1)

package mathdemo1;

public class Mathdemo1 {
    public static void main(String[] args) {

        //int -2147483648 ~ 2147483647
        System.out.println(Math.abs(-8));
        System.out.println(Math.abs(-2147483648));
        System.out.println(Math.abs(-2147483647));

//        Math.absExact(-2147483648);

        //进一法 ceil 向正无穷大方向获取最大值
        System.out.println(Math.ceil(12.34));
        System.out.println(Math.ceil(12.54));

        System.out.println(Math.ceil(-12.34));
        System.out.println(Math.ceil(-12.54));

        //进一法 floor 向负无穷大方向获取最大值
        System.out.println(Math.floor(12.34));
        System.out.println(Math.floor(12.54));
        System.out.println(Math.floor(-12.34));
        System.out.println(Math.floor(-12.54));

        //四舍五入
        System.out.println(Math.round(12.34));
        System.out.println(Math.round(12.54));
        System.out.println(Math.round(-12.34));
        System.out.println(Math.round(-12.54));

        //max
        System.out.println(Math.max(12,13));
        System.out.println(Math.min(12,13));

        //
        System.out.println(Math.pow(2,3));
        System.out.println(Math.pow(4,0.5));
        System.out.println(Math.pow(4,-2));

        System.out.println(Math.sqrt(4));
        System.out.println(Math.cbrt(9));


        System.out.println("-------------------");
        for (int i = 0; i < 10; i++) {
            System.out.println(Math.floor(Math.random() * 100) + 1);
        }

    }


}

输出：

判断一个数是不是质数？

    public static boolean isPrime(int n) {
        int count = 0;
        for (int i = 2; i < Math.sqrt(n); i++) {
            count++;
            if (n % i == 0) {
                return false;
            }
        }
        System.out.println(count);
        return true;
    }

System

public static void exit(int status);//终止当前运行的Java虚拟机


public static long currentTimeMillis();//返回系统当前时间毫秒值形式


public static void arraycopy(数据源数组,起始索引,目的地数组,起始索引,拷贝个数);//数组拷贝

        int[] a = {1,2,3,4,5};
        int[] b = new int[a.length];
//        System.arraycopy(a,0,b,2,a.length);
        System.arraycopy(a,0,b,2,3);
        for (int i=0;i<b.length;i++){
            System.out.print(b[i] + " ");
        }

如数据源数组和目的地数组都是基本数据类型，那么两者的类型必须保持一致，否则会报错；

在拷贝的时候，需要考虑数组的程度，若超出数组长度，则报错

数据源数组和目的地数组都是引用数据类型，那么子类类型可以赋值给父类类型

时间原点：1970年1月1日

Runtime

表示当前虚拟机的运行环境

public static Runtime getRuntime();//当前系统的运行环境对象


public void exit(int status); //停止虚拟机


public int availableProcessors();//获得CPU的线程数


public long maxMemory();//JVM能从系统中获取总内存大小（byte）


public long totalMemory();//JVM已经从系统中获取总内存大小(byte)


public long freeMemory();//JVM剩余内存大小（byte）


public Process exec(String command);//运行cmd命令

Object

作用：object是Java中的顶级父类，所有的类都直接或间接的继承于Object类。

Object类中的方法可以被所有子类访问

构造方法：public Object() 只有空参构造

成员方法：

public String toString();//返回对象的字符串表示形式

若打印一个对象，想看到属性值时，需要重写toString方法，在重写的方法中，把对象的属性值拼接

public boolean equals(Object obj);//比较两个对象是否相等

若没有重写equals方法，那么默认使用Object中的方法进行比较，比较的是地址值是否相等

public class ObjectDemo1 {
    public static void main(String[] args) {

        Object object = new Object();
        String str = object.toString();
        System.out.println(str);

        String s = "abc";
        StringBuilder sb = new StringBuilder("abc");

        System.out.println(s.equals(sb));
        //equals方法是被s调用的，而s是字符串，
        //所以equals要看String类中的字符串equals方法，该方法先判断参数是否为字符串
        //若是则比较内部属性，否则直接返回false

        System.out.println(sb.equals(s));
        //equals方法是被sb调用的，而sb是StringBuilder，
        //所以equals要看StringBuilder类中的字符串equals方法，该方法没有重写equals方法
        //因此使用的是Object中的，而Object中默认使用==号比较两个对象的地址值
        //而这里的s和sb记录 的地址值是不一样的，所以结果返回false

    }
}

protected object clone(int a);//对象克隆

定义：

把A对象的属性值完全拷贝给B对象，也叫对象拷贝，对象复制

细节：

方法在底层会帮我们创建一个对象，并把原对象中的数据拷贝过去

需重写Object中的clone方法

让javabean类实现Cloneable接口

创建原对象并调用clone方法即可

浅克隆：

图来自黑马程序员网课

深拷贝

浅克隆：不管对象内部的属性是基本数据类型还是引用数据类型，都完全拷贝过来

深克隆：基本数据类型拷贝值，字符串复用，引用数据类型会重新创建新的

Object中的克隆是浅克隆

Objects

Objects是一个工具类，提供了一些方法区完成一些功能

源码：

输出：

isNull源码：

BigInteger

在Java中，整数有四种类型：byte,short,int,long

在底层占用字节个数：byte1个字节，short2个字节，int4个字节，long8个字节

构造方法：

图来自黑马程序员网课

小结：若BigInteger表示的数字没有超出long的范围，可以用静态方法获取

若超出，则用构造方法获取

对象一旦创建，BigInteger内部记录的值不能发生改变，只要进行计算都产生一个新的BigInteger对象

public class Test {
    public static void main(String[] args) {
        BigInteger bd1 = new BigInteger(4,new Random());
        //0 ~ 2^4 - 1
        System.out.println(bd1);

        BigInteger bd2 = new BigInteger("10000000000000000000000000");
        System.out.println(bd2);

//        BigInteger bd3 = new BigInteger("1.1");
//        System.out.println(bd3);

        BigInteger bd4 = new BigInteger("100",10);
        System.out.println(bd4);

        BigInteger bd5 = new BigInteger("100",2);
        System.out.println(bd5);

        //字符串的数字必须是整数
        //字符串中的数字必须要跟进制吻合

        //能表示的范围比较小 long
        //在内部对常用的数字：-16 ~ 16进行了优化
        //提前把-16 ~ 16 的每一个数字先创建好BIgInteter对象，如果多次获取不会重新创建新的
        System.out.println(Long.MAX_VALUE);
        System.out.println(BigInteger.valueOf(1000));
        System.out.println(BigInteger.valueOf(9223372036854775807L));

        BigInteger bd6 = BigInteger.valueOf(16);
        BigInteger bd7 = BigInteger.valueOf(16);
        System.out.println(bd6 == bd7);

        BigInteger res = bd7.add(bd6);
        System.out.println(res);
        //此时不会修改参与计算的对象的值，而是产生了一个新的BigInteger对象记录

        System.out.println(res == bd7);
        System.out.println(res == bd6);


    }
}

正则表达式

作用：

校验字符串是否满足规则以及查询满足要求的数据

使用：

图来自黑马程序员网课

转义字符：\ 例如：\\ 前面的\是一个转义字符，改变了后面\的原本含义，将其变为一个普通的\

身份证号正则表达式：

String regex8 = "[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}[\\dXx]";

图来自黑马程序员

分组：

规则：从1开始，连续不间断；以左括号为基准，最左边的是第一组，其次为第二组

捕获分组：

后续还要继续使用本组数据，正则内部使用：\\组号正则外部使用：$组号

非捕获分组：分组之后不需要再用本组数据，仅仅是把数据括起来。

图来自黑马程序员

package regex;

public class Demo3 {
    public static void main(String[] args) {
        // \\组号：表示把第X组的内容再拿出来用一次
        String regex1 = "(.).+\\1";
        System.out.println("hjdsksjds".matches(regex1));

        String regex2 = "(.+).+\\1";
        System.out.println("hjdsksjhj".matches(regex2));

        //(.)把首字母看做一组
        // \\1 把首字母
        String regex3 = "((.)\\2*).+\\1";
        System.out.println("aaa632873aab".matches(regex3));

        String regex4 = "(.)\\1+";
        String str = "hhh jskjdi jewi ej jje wjwiww";
        System.out.println(str.replaceAll(regex4,"$1"));


        //非捕获分组
        String regex5 = "[1-9]\\d{16}(?:\\d|X|x)\\1";
        System.out.println("37827372738462734X".matches(regex5));
    }
}