Yqf745873310的博客

public class DouDiZhu2 { public static void main(String[] args) { // Map储存牌的索引和组装好的牌 HashMap<Integer, String> poker = new HashMap<>(); // List储存牌的索引 ArrayList<Integer> pokerIndex = new ArrayList<>

首先，设置断点。比如在方法第一行或者报错的行右键，选择Debug功能按钮介绍：这8个按钮的快捷键及作用依次为：1、（Alt+F10）：如果你的光标在其它行或其它页面，点击这个按可跳转到当前代码执行的行。2、（F8）：步过，一行一行地往下走，如果这一行上有方法则不会进入方法。3、（F7）：步入，如果当前行有方法，可以进入方法内部，一般用于进入自定义方法。内，不会进入宫方类库的方法。4、（Alt+Shift+F7）：强制步入，能进入任何方法，查看底后源码的时候可以以此进入官方类库的方.

是适用于List、Set、Map接口，不适用于接口的实现类；of方法返回值是一个不能改变的集合，不能再add或者put进去东西；Set和Map接口调用of的时候不能有重复元素。public class OfLianXi { public static void main(String[] args) { List<Integer> list = List.of(1, 2, 3, 4); //直接用List接口添加，返回一个List类型 .

Map集合Collection 和 Map 框架的对比Collection 和 Map 框架的联系Map 的方法总结使用Entry键值对对象遍历MapCollection 和 Map 框架的对比java集合是java提供的工具包，包含了常用的数据结构：集合、链表、队列、栈、数组、映射等。Java集合工具包位置是java.utiljava集合主要可以分为4个部分：List列表、Set集合、Map映射、工具类(Iterator迭代器、Enumeration枚举类、Arrays和Collections)。

Collection后面加个s是怎么个情况？Collection是集合类的上级接口，继承与他有关的接口主要有List和Set；Collections是针对Collection集合类的一个工具类，不能被实例化，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全等操作。Collections常用方法如下：public static <T> boolean addAll(Collection<T> c, T.....elements)：往集合中一次性添加一些元素。pub

数据类型确定，参数数量不确定，可使用可变参数（JDK1.5后的新特性）：public class VarArgs { public static void main(String[] args) { int i = plus(10, 20, 6); System.out.println("求和结果为：" + i);//求和结果为：36 } public static int plus(int... arr) { //System.o

Collection接口: 单列集合最顶层的接口，单列集合中的共性内容，所有单列集合都可以使用。List接口 / 集合: 有存储顺序，允许存储重复元素。ArrayList类（重点）: 底层是数组实现的, 查找快, 增删慢。由于是数组实现，在增和删的时候会牵扯到数组增容，以及拷贝元素，所以慢。而数组是可以直接按索引查找, 所以查找时较快，一个普通的for循环可以遍历。LinkedList类: 底层是链表实现的, 增删快, 查找慢。由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前.

前面简单写过Collection层次结构如下：Collection接口: 单列集合最顶层的接口，单列集合中的共性内容，所有单列集合都可以使用。List接口 / 集合: 有存储顺序，允许存储重复元素。ArrayList类（重点）: 底层是数组实现的, 查找快, 增删慢。由于是数组实现，在增和删的时候会牵扯到数组增容，以及拷贝元素，所以慢。而数组是可以直接按索引查找, 所以查找时较快，一个普通的for循环可以遍历。LinkedList类: 底层是链表实现的, 增删快, 查找慢。由于链表实现, 增

斗地主发牌案例准备牌ArrayList<String> poker = new ArrayList<>();洗牌 Collections.shuffle(poker);发牌看牌import java.util.ArrayList;import java.util.Collections;public class DouDiZhu { public static void main(String[] args) { // 1、准备牌

泛型的使用定义和使用含有泛型的类定义和使用含有泛型的接口泛型通配符<?>的使用定义和使用含有泛型的类public class FanXing<T> { public void print(T t) { System.out.println(t); }}public class Demo { public static void main(String[] args) { FanXing<String> dx

为方便的处理集合Collection中的元素，Java中出现了一个对象叫做 迭代器(Iterator)，该对象提供了一些方法专门处理集合中的元素。主要方法（下例中）：boolean b = iter.hasNext(); // 判断是否还有下一个元素？String s = iter.next(); // 取出下一个元素import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;public

Collection层次结构Collection接口: 单列集合最顶层的接口，单列集合中的共性内容，所有单列集合都可以使用。List接口 / 集合: 有存储顺序，允许存储重复元素。ArrayList类（重点）: 底层是数组实现的, 查找快, 增删慢。由于是数组实现，在增和删的时候会牵扯到数组增容，以及拷贝元素，所以慢。而数组是可以直接按索引查找, 所以查找时较快，一个普通的for循环可以遍历。LinkedList类: 底层是链表实现的, 增删快, 查找慢。由于链表实现, 增加时只要让前一个元

StringBuilder类与String类的区别由于String一旦初始化就不可改变长度，简单的字符串拼接其实是创建了新的String对象，再把拼接后的内容赋值给新的对象。在频繁修改的情况下会频繁创建对象，而StringBuilder从头到尾只有一个实例对象，节省资源，效率提高。那么StringBuilder类如何做到的呢？以下是源码：abstract class AbstractStringBuilder implements Appendable, CharSequence { /**

Date类、DateFormat类Date类DateFormat类Date类System.out.println(System.currentTimeMillis());//输出：1592919245566//解释：距离197.01.01 00:00:00//这是格林尼治时间，中国加8小时//已过去1592919245566(long型)毫秒Date date1 = new Date();System.out.println(date1);//输出：Tue Jun 23 21:43:07

Object类java.lang.Object中描述的所有方法子类都可以使用，每个类都使用Object类作为超类，所有对象（包括数组）都实现这个类的方法。如果一个类没有指定父类，默认就是继承Object类，即下面两句是一样的:class Person { }class Person extends Object { }...

前面通常是这样定义集合：ArrayList<String> list = new ArrayList<>();按住 Ctrl 鼠标点击ArrayList后跳转发现public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{...}，继续按住 Ctrl 鼠标点击List后跳转发现

对于常见的成员变量：String str=“哈哈哈”，实际上String就是一个类，只不过是JDK作者写的。同样，我们也可以自定义一个类当作成员变量。比如在游戏中，英雄是一个类，在设定英雄类的成员变量的时候，我们想给英雄配备一把武器。问题是其他英雄也要有武器，而且武器有很多参数，因此我们把武器也创建成一个类，武器类给不同的英雄类当成员变量使用，详见下例：public class Hero { private String name; // 英雄名 private int age;

接口的使用需要一个实现类的对象，有时候只需要使用一次，那么能不能跳过实现类的定义呢？同样的，一个父类的实现有时候也需要靠子类，这个子类的定义可以省略吗？

局部内部类（在方法内部的类）结构public class OuterClass { // 外部类 public void OuterMethod() { // 外部类方法 class InnerClass { // 局部内部类,class前什么都不能写 public void InnerMethod() {...} // 局部内部类的方法 } }}public class OuterClass {

如果这三处的变量名不同，则直接输出即可public class OuterClass { int OutNum = 10;// 外部类的成员变量 public class InnerClass { int InnerNum = 20;// 内部类的成员变量 public void InnerMethod() { int InnerLocalNum = 30;// 内部类的方法的局部变量 System.ou

内部类和外部类的书写结构public class OuterClass { // 外部类 public class InnerClass { // 成员内部类 int InnerName; // 内部类成员变量 public void InnerMethod() {...} // 内部类成员方法 } int OuterName; // 外部类成员变量 public void OuterMethod() {...} // 外部类成员方法}

四种权限修饰符在访问时的权限区别公共 public受保护 protected默认 default私有 private同一类（我自己）可访问 √可访问 √可访问 √可访问 √同一个包（我老婆）可访问 √可访问 √可访问 √不同包的子类（我儿子）可访问 √可访问 √不同包任何类（陌生人）可访问 √...

final 代表最终的、不可变的四种常见用法：修饰一个类不能有任何子类（太监类），因此该类的成员方法都不能被覆盖重写。这里可以看出final和abstract是矛盾的，不能同时出现的。一用final修饰，类的香火就断了（不能有儿子了）。修饰一个方法最终方法，该方法不能被覆盖重写。修饰一个局部变量一次赋值，终生不变。对于基本数据类型：终生不变指的是数据不可变，final int num=6；，当然也可以先int num，再赋值为6。但之后不能再对num赋值，哪怕再赋值6也不行，

下面为一个电脑类（class）。除了自身开关机，电脑的功能在于使用各种设备。但是作为电脑来说，只需要提供一个标准的USB母口，那么任何USB公口都可以在电脑上使用。于是定义了一个“使用设备”方法，传入参数为usb类型。public class Computer { public void powerOn() { System.out.println("电脑开机"); } public void powerOff() { System.out.pri

extends 与 implements 都可以实现代码复用，提高开发效率，下面粗浅地对比一下两者差别：extendsimplementsextends是子类继承父类的关键字implements是实现接口的关键字意义：多个类部分功能相同，则抽象出一个类来存放相同部分提高代码简洁性，其他类要用到这部分功能时可以继承这个类，这个父类最大限度抽取了共性，这个抽象类除了被继承没有任何意义意义：如果多个类处理的目标相同，但方法不同。则定义一个接口，也就是一种协议，目的在建立一种类与类间

接口是多个类的公共规范，是一种引用数据类型。接口的定义：public interface 接口名｛…｝接口中可以包含的内容，[ ] 中的内容可以省略：成员变量，即常量[public] [static] [final] 数据类型 常量名 = 数据值;接口中常量必须赋值，一旦赋值不可改变，常量名称完全大写，用下划线分隔抽象方法，接口最重要的内容[public] [abstract] 返回值类型 方法名(参数);实现类必须覆盖重写接口所有抽象方法，除非实现类是抽象类默认方法，java8新特性

前面提到，类中的静态方法推荐用【类.静态方法】的格式调用接口中也类似：public interface InterfaceStatic { public static void methodStatic() { // public可省略 System.out.println("这是接口中的静态方法"); }}public class InterfaceStaticImpl implements InterfaceStatic { public static

首先，我们有一个接口，接口内有一抽象方法methodAbstract1public interface MyInterface { // 注意用interface而不是class public abstract void methodAbstract1(); // public和abstract可有可无但不能写别的，比如private}该接口有以下MyInterfaceA、B两个实现类已投入使用public class MyInterfaceA implements MyInte

父类：用户类// 用户类public class User { private String name; private int money; public User() { } public User(String name, int money) { this.name = name; this.money = money; } // 显示当前用户余额 public void show() {

》创建一个class前写abstract关键字的抽象类，抽象类不能创建对象，只能创建其非抽象子类的对象。如本例抽象类名为 “形状类型”，我们的最终目的是计算这个形状的面积。注意：含有抽象方法的类必须是抽象类，但抽象类不一定要有抽象方法。》抽象类中可以有抽象方法，抽象方法没有方法体（直接分号结尾没大括号）。如本例中的第一个方法：使用简单公式计算面积，可传入的参数为a。由于不知道具体形状，无法找到简单公式来计算面积，故为抽象方法。》抽象类中也可以有普通成员方法，即不带abstract关键字的方法。如本例中.

【super】关键字用来访问父类内容在子类的成员方法中，访问父类的成员变量；在子类的成员方法中，访问父类的成员方法；在子类的构造方法中，访问父类的构造方法（构造函数中的第一条语句）。【this】关键字用来访问本类内容在本类的成员方法中，访问本类的成员变量；在本类的成员方法中，访问本类的另一个成员方法；在本类的构造方法中，访问本类的另一个构造方法（是构造函数中的第一条语句）。...

在继承中，不同位置定义的变量调用方法注意区分，以下面的4个同名变量num为例，分清访问方式：先创建一个父类public class Fu { int num = 1; public void fuMethod(){ int num =0; System.out.print(num); System.out.println(this.num); }}再写个子类，继承父类（extends Fu）public clas

话不多说上代码import java.util.Arrays;// 一个与数组相关的工具类，提供大量静态方法以实现数组常见操作public class ArraysDemo { public static void main(String[] args) { // 将数组变为字符串（格式[元素1,元素2,元素3。。。]） int[] intArray = {10, 20, 30, 40, 50}; String str = Arrays.to

继续上文的内容静态关键字static修饰成员方法例子类：Main：补充：静态不能访问非静态Java中，方法可以用static关键字修饰【非static方法】归属于对象，要先创建对象，而后才可以使用非static方法；【static方法】归属于类，不需要创建对象就可以被调用。无论成员变量还是成员方法，经static修饰后，推荐以【类.】的方法进行调用。即便写【对象.】的格式调用，在编译时仍然会被自动改成【类.】的格式。即推荐以下格式调用：用【类名称.静态变量】的格式调用静态变量用【类名称.静态

静态关键字static修饰成员变量static关键字遇到了什么问题？怎么解决？举例：Student类mian函数总结静态变量实例变量static关键字遇到了什么问题？场景：创建了一个学生类，实例化后每个学生将会有单独属于自己的（姓名、学号、班内序号）。然而，这些学生有个共同的班级。如果单独管理每个对象的班级，常常带来不便。如，“五年级2班” 的40个学生一年后统统变成了 “六年级2班” 的学生。怎么解决？可以使用静态关键字【static】修饰。为某特定数据类型或对象分配单一的存储空间，而与创建对

字符串使用方法字符串一般操作字符串的截取方法字符串的转换方法字符串的替换方法字符串的分割方法上篇文章提到了两个字符串内容的比较：对于引用类型来说，直接用==进行的是字符串地址值的比较，同一地址返回 true。而若想比较字符串的内容是否一致，用str1.equals(str2)；本文简介其他常见的操作方法。字符串一般操作获取长度 ——str.length()获取第3个字符是什么 ——str.charAt(2)查找“我们”在字符串中的位置 ——str.indexOf(“我们”)public cl

ArrayList类型作为方法的参数，按格式｛元素 # 元素 # 元素…｝打印集合import java.util.ArrayList;public class PrintArrayListDemo { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); list.add("关羽"); list.add("

Java中的基本数据类型不是对象，没有方法和属性。然而，在集合ArrayList中，泛型只能是引用类型。这时候如何向中存放int类型呢？答：用包装类Integer// 错误写法: ArrayList<int> list = new ArrayList<>(); ArrayList<Integer> list = new ArrayList<>();包装类让这8种基本数据类型拥有方法和属性，以实现对象化交互。区别：基本类型用于存储值，直接赋值即可

对象数组其实对象也可以放在数组里。对象数组，即存储的内容为类对象的数组（实际存放的是对象地址），对于一个叫做Person的类，对象数组array的创建方法如下：Person[] array = new Person[3]; // 长度为3的用于存放Person类对象的数组然后就可以实例化出3个对象，并将3个对象的地址赋给array[0]、array[1]、array[2]。然而，很多时候我们在定义数组时不能预先确定其长度，而数组有一个缺点，程序运行期间长度不可变。ArrayList类下面的例子

Java中关于随机数的生成，可以调用Math类中的Math.random()方法生成一个 [ 0.0, 1.0）的伪随机数，通过放缩来生成其它范围内的数字。另一个方法是通过Random类定义一个随机对象：import java.util.Random; // 导包Random r = new Random(); // 创建int a = r.nextInt(100); // 使用上面的程序中，返回一个伪随机数给变量a，它是取自此随机数生成器序列的 [0,100）之间均匀分布的 int 值