java语法记录

小小小小菜鸡

已于 2023-07-06 16:38:37 修改

阅读量70

点赞数

分类专栏：代码随想录刷题 Java核心技术·卷1 文章标签： java

于 2023-02-22 11:01:59 首次发布

本文链接：https://blog.csdn.net/qq_42295590/article/details/129158568

版权

Java核心技术·卷1 同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

代码随想录刷题

4 篇文章 0 订阅

订阅专栏

Java代码细节

字符串拼接用StringBuilder而不是String。
所有整数注意溢出问题，优先用减和除，注意用long。

Java库函数

输入并处理字符串

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scanner = new Scanner(System.in);
		String nextLine = scanner.nextLine();
		System.out.println(nextLine);
		String[] split = nextLine.split(" ");
		System.out.println(Arrays.toString(split));
		String join = String.join(",", split);
		System.out.println(join);
	}

数组翻转Collections.reverse(）

必须先把数组转成list。

void java.util.Collections.reverse(List<?> list)

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scanner = new Scanner(System.in);
		String nextLine = scanner.nextLine();
		System.out.println("nextLine: "+nextLine);
		String[] split = nextLine.split(" ");
		
		System.out.println("split: "+Arrays.toString(split));
		ArrayList<String> nextLineArrayList=new ArrayList<String>(Arrays.asList(split));  //必须先把数组转成list。记得新建ArrayList，不然Arrays.asList(split)返回的list不可变，且不能调用add，remove
		System.out.println("nextLineArrayList: "+nextLineArrayList.toString());
		Arrays.sort(split);
		System.out.println("after sort split: "+Arrays.toString(split));
		System.out.println("after sort split, nextLineArrayList unchange: "+nextLineArrayList.toString());
		Collections.reverse(nextLineArrayList);
		System.out.println("after Collections.reverse nextLineArrayList: "+nextLineArrayList.toString());
	}

在这里插入图片描述

split()函数用""会产生空字符串 “”，应该正则匹配连续的空白字符作为分隔符分割

public String[] split(String regex)，将此字符串拆分为给定regular expression的匹配项。
此方法的作用就像通过使用给定表达式和limit参数为零调用双参数split方法一样。因此，结尾的空字符串不包含在结果数组中。
例如，字符串"boo:and:foo"使用以下表达式产生以下结果：

Regex	Result
:	{ “boo”, “and”, “foo” }
o	{ “b”, “”, “:and:f” } // boo的两个o之间split出了一个空字符串“”

所以下面这个例子里，s被split的字符串有5个元素，包括两个空字符串（末尾的空字符串被丢弃）。用join拼接后生成a-good—example。如果用空格分隔和拼接，问题会更有迷惑性。即"a good example"字符串先split，再join后，不可能产生"a good example"，而依旧是"a good example"。

 public static void main(String[] args) {
    	Solution solution = new Solution();
		String s ="a,good,,,example,,,";
		System.out.println(s);
		String[] split = s.split(",");
		System.out.println(Arrays.toString(split));
		System.out.println(String.join("-", split));
		//System.out.println(solution.reverseWords(s));
	}

在这里插入图片描述

class Solution {
    public String reverseWords(String s) {
        // 除去开头和末尾的空白字符
        s = s.trim();
        // 正则匹配连续的空白字符作为分隔符分割
        List<String> wordList = Arrays.asList(s.split("\\s+"));
        Collections.reverse(wordList);
        return String.join(" ", wordList);
    }
}

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/reverse-words-in-a-string/solution/fan-zhuan-zi-fu-chuan-li-de-dan-ci-by-leetcode-sol/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

https://blog.csdn.net/servermanage/article/details/102662085

二维List

List<List<Integer>> resList=new ArrayList<List<Integer>>();

应用：TreeSet中用Comparator给Set排序

Comparator不要返回0

import java.util.*;
import java.util.function.BiConsumer;

public class Solution {


    public int[] topKFrequent(int[] nums, int k) {
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        for (int val : nums) {
            hashMap.merge(val, 1, Integer::sum);
        }
        int topFre1 = 0, topFre2 = 1;
        Set<Map.Entry<Integer, Integer>> entries = hashMap.entrySet();
        // lambda表达式
        TreeSet<Map.Entry<Integer, Integer>> entries1=new TreeSet<>((o1, o2) ->
        {
            int tem = o2.getValue()-o1.getValue();
            return tem==0?1:tem;    //如果返回0，TreeSet就不会创建这个与上一个相同的元素，所以返回1
        });
        entries1.addAll(entries);
        int[] res=new int[k];
        Iterator<Map.Entry<Integer,Integer>> it= entries1.iterator();

        for(int i=0;i<k;i++)
        {
            res[i]=it.next().getKey();
        }
        return res;
    }

    public static void main(String[] args) {
        int[] nums = {1,2};
        int k = 2;
        Solution solution = new Solution();
        System.out.println(Arrays.toString(solution.topKFrequent(nums, k)));
    }
}

进制转换输入输出

        String s="FFFF";
        int a=Integer.parseInt(s,16);
        System.out.println("十进制："+a);
        System.out.printf("%X",a);
        System.out.println();
        String hex=Integer.toHexString(a).toUpperCase();
        String binaryString = Integer.toBinaryString(a);
        System.out.println(binaryString);
        System.out.println(Integer.parseInt(binaryString,2));
        System.out.println(hex);

Integer.parseInt(String s)

其中s除了正负号，只能含有数字。所以“200.0”无法变成Integer。
Integer.parseInt(s,2)还可以设置进制。注意s只能有数字，不能有0x这种表示16进制的前缀。

s.split()

其中，即使s为空，split后依旧会产生一个长度为1的数组。数组唯一一个元素是一个空串。

值传递，修改变量的引用无效！

// res={999，999};

void changeArrays(int[] res)  //res依旧是原值{999，999}
{
       int[] newRes={0,0};
       res=newRes;
}

void changeArrays(int[] res)  //res依改变为{0，999}
{
      res[0]=0;
}

字符串compareto函数中

字典序比较时，大写字母比小写字母小。ASCII码中，大写字母也在小写字母前面。
compareto函数首先比较开始元素的大小，只有元素都相同的时候，才比较length。length小就小。比如"string".compareto(“string123”)返回负值。

接口、抽象类、内部类有没有构造器？

接口没有构造器（接口无法实例化，接口所有字段都是public static final），抽象类有构造器（如果没有，会自动生成无参构造函数）。
普通内部类，局部内部类，static内部类都有构造器，只有匿名内部类没有构造器。

接口可以继承接口，不能继承任何类

接口可以继承接口，不能继承任何类。

所有类，包括普通类，抽象类，内部类（匿名内部类除外），都有构造器。而接口没有构造器，没有非常量字段。接口一旦继承类，一定会有构造器，不可能。

类（包括抽象类）可以同时继承一个类，实现多个接口。
抽象类可以继承普通类（非抽象类）。普通类继承抽象类，这个普通类不是抽象类，就要实现所有抽象方法。
一个接口可以继承多个接口. interface C extends A, B {}是可以的.

一个类可以实现多个接口: class D implements A,B,C{} 但是一个类只能继承一个类,不能继承多个类 class B extends A{} 在继承类的同时,也可以继承接口: class E extends D implements A,B,C{} 这也正是选择用接口而不是抽象类的原因。

子类不能继承父类的私有属性

Java官方文档的解释：子类不能继承父类的私有属性，但是如果子类中公有的方法影响到了父类私有属性，那么私有属性是能够被子类使用的。
个人理解：子类是由父类和自己特有的方法和字段组成的。子类中含有一个父类，自然拥有父类的所有域（包括私有字段和方法），但是这归根结底还是父类自己的，即使是public字段和方法，也是父类自己的。比如父类Employee有一个子类Manager。那manager对象拥有一个employee，但是employee的方法和字段归根结底是employee自己的，manager可以通过employee的public方法用，但还是在通过employee在用。就好比经理手下有一个工人，经理可以让工人做打包、上货，就好像经理也能完成打包上货工作。但是，打包上货归根结底是手下的工人干的。打包上货这些技能归根结底属于工人。
在这里插入图片描述

两个Integer比较用equals方法！！！！

刷题的时候，比较List<Integer>的相邻元素的时候，踩进了这个大坑。应该用equals，用成了“==”。结果出现有的测试用例能过，有的过不了。很久才找到这个问题。
详细可见
只有基本数据类型的比较可以用==。

在这里插入图片描述

反射new对象

getConstructor(String.class)通过class指定构造器。newInstance(“123”)根据参数创建对象。

Class<String> stringClass = String.class;
      Class cl=String.class;
      try {
         cl.getConstructor(String.class).newInstance("123");
      } catch (Exception e) {
         throw new RuntimeException(e);
      }

在这里插入图片描述

子类不能重写父类的私有方法

1.父类中私有方法不能被重写。因为子类无法继承父类的私有方法和属性，虽然子类拥有父类的私有域，但只能看不能访问。
2. 子类可以重新实现父类的该方法,不会有冲突,但是你重新实现的方法,不叫重写也不叫重载,是一个该子类新增的方法,和子类的一般扩展方法一样。

public class A {
    private void print()
    {
        System.out.println("A");
    }
}

 class B {
    private void print()
    {
        System.out.println("B");
    }
}