Java编程题笔试常用API

布满荆棘的人生 2023-02-26 05:21 1阅读 0赞

前言：有家有公司联系上了我，然后要在牛客网参加一场笔试，之前搞ACM的时候都是用的C++，现在做后端开发都用java了，想用java答题了，虽然java麻烦点，但是从长远看，更有利于我java水平的提高，所以总结了一下java在编程题中常用的API，到时候好查，**不保证一定没问题，只是我自己的理解，事关面试很重大还是要自己敲一遍的，出问题别找我**。

参考：

[https://blog.csdn.net/weixin\_43217942/article/details/83043120][https_blog.csdn.net_weixin_43217942_article_details_83043120]

[https://www.cnblogs.com/-maji/p/7123248.html][https_www.cnblogs.com_-maji_p_7123248.html]

[https://blog.csdn.net/weixin\_42696192/article/details/102453797][https_blog.csdn.net_weixin_42696192_article_details_102453797]

[https://blog.csdn.net/daoshen1314/article/details/100581136][https_blog.csdn.net_daoshen1314_article_details_100581136]

[https://blog.csdn.net/qq997404392/article/details/78085783][https_blog.csdn.net_qq997404392_article_details_78085783]

[https://www.jianshu.com/p/53cc95a4eea7][https_www.jianshu.com_p_53cc95a4eea7]

[https://blog.csdn.net/q610376681/article/details/89220585\#2.5%20TreeSet][https_blog.csdn.net_q610376681_article_details_89220585_2.5_20TreeSet]

[https://blog.csdn.net/qq\_39326472/article/details/90751089][https_blog.csdn.net_qq_39326472_article_details_90751089]

**目录**

第一章 输入输出

第二章 数组

第三章 字符串操作

3.1 StringBulder

3.2 其它

第四章 排序

4.1 普通排序

4.2 自定义排序

4.2.1 Arrays.sort

4.2.2 Collection.sort

第五章 大数与浮点数

5.1 概述

5.2 相关API

第六章 map、set、list的使用

6.1 list

6.2 set

6.2.1 遍历

6.2.2 排序

6.3 map

6.3.1 常用API

6.3.2 遍历map

6.3.3 排序

6.4 stack

第七章 数学知识

7.1 数字取整

7.2 math部分API

7.3 排列组合

--------------------

# 第一章 输入输出 #

输入输出是最基本的了，我印象中的输入输出有两种：

一种是给个数字然后不断输入数字：

Scanner input=new Scanner(System.in);
    while(input.hasNextInt()){
         int n = input.nextInt();       
    }

一种是输入个数字，然后一行行，不断输入字符串：

Scanner input=new Scanner(System.in);
    while(input.hasNext()){
        String str = input.next();
    }

next()与nextLine()区别很明确：

next() 方法遇见第一个有效字符（非空格，非换行符）时，开始扫描，当遇见第一个分隔符或结束符(空格或换行符)时，结束扫描，获取扫描到的内容，即获得第一个扫描到的不含空格、换行符的单个字符串。

使用nextLine()时，则可以扫描到一行内容并作为一个字符串而被获取到。

最后注意要引入工具类

import java.util.Scanner;

# 第二章 数组 #

java创建数组需要new，数组分为基本类型的数组与字符串数组

创建基本类型的数组：

int[] arr2 = {10,20,30};
    
    arr4 = new char[] {'a','b','c'};
    
    int[] arr = new int[10];

字符串数组：

String[] strArray={"1","2","3"};
    String[] strArray = new String[10];
    String[] strArray1 = new String[]{"aaa","aa","aa"};

二维数组：

int[][] arr = {
       {1,2,3},{4,5,6},{7,8,9}};
    int[][] arr = new int[m][n];

遍历：

最简单的，直接都for循环，上限是数组名.length即可

# 第三章 字符串操作 #

## 3.1 StringBulder ##

Java里的String是不能更改的，所以修改字符串得用StringBuilder，注意StringBuilder不是线程安全的。

public class Copy3 {
    
        public static void main(String[] args) {
            //构造实例化
            StringBuffer strbu = new StringBuffer("hello world\t");
            char[] a = {'l','o','y','o','u'};
            //调用方法
    
            System.out.println(1+"\t"+strbu.append(true));            //append(boolean b);
            System.out.println(2+"\t"+strbu.append('a'));            //append(char b);
            System.out.println(3+"\t"+strbu.append(a));                //append(char[] b);
            System.out.println(4+"\t"+strbu.capacity());            //capacity();
            System.out.println(5+"\t"+strbu.charAt(10));            //charAt(int index);
            System.out.println(6+"\t"+strbu.delete(3, 9));            //delete(int start, int end);
            System.out.println(7+"\t"+strbu.insert(5, false));        //insert(int offset, boolean b);
            System.out.println(8+"\t"+strbu.substring(7));            //substring(int start)
            System.out.println(9+"\t"+strbu.reverse() );            //reverse()
    
        }
    
    }

![format_png][]

##  3.2 其它 ##

字符串替换：

//起始位置、结束位置
    stringBuilder.replace(1,2,"aaaaaaa");
    System.out.println(stringBuilder);

注：String有字符串模式匹配替换

字符串大小比较：

String t1="20131011";
      String t2="20131030";
      int result = t1.compareTo(t2);

result大于0，则t1>t2；

result等于0，则t1=t2；

result小于0，则t1<t2；

# 第四章 排序 #

## 4.1 普通排序 ##

注意引入：

mport java.util.Arrays;

数组排序：

int[] arr = {4,3,5,1,7,9,3};
      Arrays.sort(arr);

部分位置排序：

int[] arr = {4,3,5,1,2,9,3,0};
       
      Arrays.sort(arr,1,4);

## 4.2 自定义排序  ##

Collection.sort是给List<T>进行排序，而Arrays.sort是给数组进行排序

### 4.2.1 Arrays.sort ###

两种写法（注意引入包）：

import java.util.Arrays;
    import java.util.Comparator;
    import java.util.Scanner;
     
    class node{
    	int x;
    }
    class cmp implements Comparator<node>{
    	@Override
    	public int compare(node o1, node o2) {//降序
    		if(o1.x<o2.x) return 1;
    		else if(o1.x==o2.x) return 0;
    		else return -1;
    	}
    }
    public class 自定义排序 {
        public static void main(String[] args) {
    		Scanner scan=new Scanner(System.in);
    		int n=scan.nextInt();
    		node a[]=new node[15];
    		for(int i=0;i<n;i++){
    			a[i]=new node();//别忘了new空间
    			a[i].x=scan.nextInt();
    		}
    		Arrays.sort(a,0,n,new cmp());
    		for(int i=0;i<n;i++){
    			System.out.println(a[i].x);
    		}
    	}
    }

import java.util.Arrays;
    import java.util.Comparator;
    import java.util.Scanner;
     
    class node implements Comparable<node>{
    	int x;
    	@Override
    	public int compareTo(node o) {
    		// TODO Auto-generated method stub
    		if(this.x<o.x) return 1;
    		else if(this.x==o.x) return 0;
    		else return -1;
    	}
    }
    public class Main{
        public static void main(String[] args) {
    		Scanner scan=new Scanner(System.in);
    		int n=scan.nextInt();
    		node a[]=new node[15];
    		for(int i=0;i<n;i++){
    			a[i]=new node();//别忘了new空间
    			a[i].x=scan.nextInt();
    		}
    		Arrays.sort(a,0,n);
    		for(int i=0;i<n;i++){
    			System.out.println(a[i].x);
    		}
    	}
    }

### 4.2.2 Collection.sort ###

public class run {
        
        public static void main(String[] args) throws Exception 
        {
            //类A实现了Comparable接口，所以可以直接使用Collections.sort()方法
            A a1 = new A(3);
            A a2 = new A(1);
            A a3 = new A(2);
            ArrayList<A> lista = new ArrayList<A>();
            lista.add(a1);
            lista.add(a2);
            lista.add(a3);
            Collections.sort(lista);
            for(A a : lista)
                System.out.println(a.value);//输出123
            
            //类B没有实现Comparable接口，通过自定义的比较器Comparator来使用Collections.sort()方法
            ArrayList<B> listb = new ArrayList<B>();
            B b1 = new B(5);
            B b2 = new B(7);
            B b3 = new B(6);
            listb.add(b1);
            listb.add(b2);
            listb.add(b3);
            BComparator comparator = new BComparator();
            Collection.sort(listb);//错误，会报错，缺少比较器
            Collections.sort(listb, comparator);//正确
            for(B b : listb)
                System.out.print(b.value);//输出567
        }
    
    }
    //类A实现了Comparble接口
    class A implements Comparable<A> {
        public int value;
        //升序排列
        @Override
        public int compareTo(A o) {
            if(this.value > o.value)
                return 1;
            else if(this.value < o.value)
                return -1;
            else
                return 0;
        }
        public A (int i) {
            value = i;
        }
    }
    //类B是一个普通类
    class B {
        public int value;
        public B(int i) {
            value = i;
        }
    }
    //定义比较器，实现了Comparator接口，可以用来作为输入参数定义比较方法
    class BComparator implements Comparator<B> {
        //升序排列
        @Override
        public int compare(B o1, B o2) {
            if(o1.value > o2.value)
                return 1;
            else if(o1.value < o2.value)
                return -1;
            else
                return 0;
        }
        
    }

# 第五章 大数与浮点数 #

## 5.1 概述 ##

import java.math.BigInteger;

BigInteger支持任意精度的整数，在运算中可以准确地表示任何大小的整数值，而不会丢失任何信息。BigDecimal支持任何精度的定点数，可以用它进行精确的货币计算。

赋值：

BigInteger bi = new BigInteger(“100”);
    BigInteger bi = BigInteger.valueOf(100); 
    
    BigDecimal bd = new BigDecimal(100);
    BigDecimal bd = BigDecimal.valueOf(100);

## 5.2 相关API ##

BigInteger：

import java.math.BigInteger;
    import java.util.Random;
    /*
     * 测试BigInteger类的一些函数
     */
    public class BigIntegerDemo 
    {
        public static void main(String[] args)
        {
            System.out.println("构造两个BigInteger对象");
            //BigInteger(int numBits,Random rnd)
            //构造一个随机生成的 BigInteger，它是在 0 到 (2^numBits - 1)（包括）范围内均匀分布的值
            BigInteger bi1 = new BigInteger(55,new Random());
            System.out.println("bil = " + bi1);
    
            //BigInteger(byte[] val)   
            //将包含 BigInteger 的二进制补码表示形式的 byte 数组转换为 BigInteger。
            BigInteger bi2 = new BigInteger(new byte[]{3,2,3});
            System.out.println("bi2 = " + bi2);
    
            //加
            System.out.println("bi1 + bi2 = " + bi1.add(bi2));
            //减
            System.out.println("bi1 - bi2 = " + bi1.subtract(bi2));
            //乘
            System.out.println("bi1 * bi2 = " + bi1.multiply(bi2));
            //指数运算
            System.out.println("bi1的2次方 = " + bi1.pow(2));
            //整数商
            System.out.println("bi1/bi2的整数商: " + bi1.divide(bi2));
            //余数
            System.out.println("bi1/bi2的余数: " + bi1.remainder(bi2));
            //整数商+余数  
            System.out.println("bi1 / bi2 = " + bi1.divideAndRemainder(bi2)[0] +   
                    "--" + bi1.divideAndRemainder(bi2)[1]);
            System.out.println("bi1 + bi2 = " + bi1.add(bi2));  
            //比较大小,也可以用max()和min() 
            if(bi1.compareTo(bi2) > 0)
            {
                System.out.println("bi1 is greater than bi2");
            }
            else if(bi1.compareTo(bi2) == 0)
            {
                System.out.println("bi1 is equal to bi2");
            }
            else if(bi1.compareTo(bi2) < 0) 
            {
                System.out.println("bd1 is lower than bd2");  
            }
            //返回相反数
            BigInteger bi3 = bi1.negate();
            System.out.println("bi1的相反数:" + bi3);
            //返回绝对值
            System.out.println("bi1的绝对值:" + bi3.abs());
        }
    }

BigDecimal：

import java.math.BigDecimal;
    /*
     * 测试BigDecimal类的一些函数
     */
    public class BigDecimalDemo
    {
        public static void main(String[] args)
        {
            System.out.println("构造两个BigDecimal对象");
            //用char[]数组创建BigDecimal对象,第二个参数为位移offset,  
            //第三个参数指定长度
            BigDecimal bd1 = new BigDecimal("3464656776868432998434".toCharArray(),2,15);  
            System.out.println("bd1 = " + bd1);  
            //用double类型创建BigDecimal对象  
            BigDecimal bd2 = new BigDecimal(134258767575867.0F);  
            System.out.println("bd2 = " + bd2);
    
            //加  
            System.out.println("bd1 + bd2 = " + bd1.add(bd2));  
            //减  
            System.out.println("bd1 - bd2 = " + bd1.subtract(bd2));  
            //乘  
            System.out.println("bd1 * bd2 = " + bd1.multiply(bd2));  
            //指数运算  
            System.out.println("bd1的2次方 = " + bd1.pow(2));  
            //取商的整数部分  
            System.out.println("bd1/bd2的整数商: " + bd1.divideToIntegralValue(bd2));  
            //返回余数计算为:this.subtract(this.divideToIntegralValue(divisor).multiply(divisor))  
            //System.out.println(bd1.subtract(bd1.divideToIntegralValue(bd2).multiply(bd2)));  
            System.out.println("bd1/bd2的余数: " + bd1.remainder(bd2));  
            //取商和余,即bd1.divideToIntegralValue(bd2)与bd1.remainder(bd2)   
            System.out.println("bd1 / bd2 = " + bd1.divideAndRemainder(bd2)[0] +   
                    "--" + bd1.divideAndRemainder(bd2)[1]);  
            //比较大小,也可以用max()和min()
            if(bd1.compareTo(bd2) > 0)  
    
                System.out.println("bd1 is greater than bd2");  
    
            else if(bd1.compareTo(bd2) == 0)  
    
                System.out.println("bd1 is equal to bd2");  
    
            else if(bd1.compareTo(bd2) < 0)  
    
                System.out.println("bd1 is lower than bd2");  
         //末位数据精度  
         System.out.println("bd1的末位数据精度:  " + bd1.ulp());
         }  
    }

# 第六章 map、set、list的使用 #

## 6.1 list ##

添加方法是：.add(e)；　　获取方法是：.get(index)；　删除方法是：.remove(index)； 按照索引删除；

.remove(Object o)； 按照元素内容删除；包含.contains；置换 .set(index, element);

查看索引.indexOf（）和  lastIndexOf（）；根据索引位置重新生成一个新的list（截取集合） .subList(fromIndex, toIndex)；

## 6.2 set ##

TreeSet和HashSet区别：

1、TreeSet 是二差树实现的,Treeset中的数据是自动排好序的，不允许放入null值。

2、HashSet 是哈希表实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束。

3、HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的 String对象，hashcode是一样，所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例

### 6.2.1 遍历 ###

迭代器：

Iterator<Integer> iterator = set.iterator();
            while (iterator.hasNext()) {
                iterator.next();
            }

增强型for循环：

for (int item : set) {
                // System.out.println(item);
            }

foreach：

set.forEach(item -> {
                // System.out.println(item);
            });

### 6.2.2 排序 ###

有客户化排序和字然排序，这里我比较喜欢客户化排序，就只列出客户化排序了

public class CustomerComparator implements Comparator<Customer> {
        @Override
        public int compare(Customer c1, Customer c2) {
            if(c1.getName().compareTo(c2.getName())>0)return -1;
            if(c1.getName().compareTo(c2.getName())<0)return 1;
            return 0;
        }
     
        public static void main(String args[]){
            Set<Customer> set = new TreeSet<Customer>(new CustomerComparator());
     
            Customer customer1= new Customer("Tom",5);
            Customer customer2= new Customer("Tom",9);
            Customer customer3= new Customer("Tom",2);
            set.add(customer1);
            set.add(customer2);
            set.add(customer3);
            Iterator<Customer> it = set.iterator();
            while(it.hasNext()){
                Customer customer = it.next();
                System.out.println(customer.getName()+" "+customer.getAge());
            }
        }
    }

set转list：

List<String> list1 = new ArrayList<String>(set);  
    for(int i = 0; i < list1.size(); i++){  
        System.out.println("list1(" + i + ") --> " + list1.get(i));  
    }

## 6.3 map ##

### 6.3.1 常用API ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3E2MTAzNzY2ODE_size_16_color_FFFFFF_t_70][]

### 6.3.2 遍历map ###

/**
    * 最常见也是大多数情况下用的最多的，一般在键值对都需要使用
     */
    Map <String,String>map = new HashMap<String,String>();
    map.put("熊大", "棕色");
    map.put("熊二", "黄色");
    for(Map.Entry<String, String> entry : map.entrySet()){
        String mapKey = entry.getKey();
        String mapValue = entry.getValue();
        System.out.println(mapKey+":"+mapValue);
    }
    
    
    //key
    for(String key : map.keySet()){
        System.out.println(key);
    }
    //value
    for(String value : map.values()){
        System.out.println(value);
    }
    
    
    
    Iterator<Entry<String, String>> entries = map.entrySet().iterator();
    while(entries.hasNext()){
        Entry<String, String> entry = entries.next();
        String key = entry.getKey();
        String value = entry.getValue();
        System.out.println(key+":"+value);
    }
    
    
    for(String key : map.keySet()){
        String value = map.get(key);
        System.out.println(key+":"+value);
    }

### 6.3.3 排序 ###

按键排序：

按值排序：

public class MapSortDemo {
    
     
    
        public static void main(String[] args) {
    
            Map<String, String> map = new TreeMap<String, String>();
    
            map.put("KFC", "kfc");
    
            map.put("WNBA", "wnba");
    
            map.put("NBA", "nba");
    
            map.put("CBA", "cba");
    
            Map<String, String> resultMap = sortMapByValue(map); //按Value进行排序
    
            for (Map.Entry<String, String> entry : resultMap.entrySet()) {
    
                System.out.println(entry.getKey() + " " + entry.getValue());
    
            }
    
        }
    
        /**
    
         * 使用 Map按value进行排序
    
         */
    
        public static Map<String, String> sortMapByValue(Map<String, String> oriMap) {
    
            if (oriMap == null || oriMap.isEmpty()) {
    
                return null;
    
            }
    
            Map<String, String> sortedMap = new LinkedHashMap<String, String>();
    
            List<Map.Entry<String, String>> entryList = new ArrayList<Map.Entry<String, String>>(oriMap.entrySet());
    
            Collections.sort(entryList, new MapValueComparator());
            Iterator<Map.Entry<String, String>> iter = entryList.iterator();
            Map.Entry<String, String> tmpEntry = null;
            while (iter.hasNext()) {
                tmpEntry = iter.next();
                sortedMap.put(tmpEntry.getKey(), tmpEntry.getValue());
            }
            return sortedMap;
        }
    }
    
    
    class MapValueComparator implements Comparator<Map.Entry<String, String>> {
        @Override
        public int compare(Entry<String, String> me1, Entry<String, String> me2) {
            return me1.getValue().compareTo(me2.getValue());
        }
    }

## 6.4 stack ##

差点把它忘了

定义

Stack<Integer> stack = new Stack<Integer>();

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3E2MTAzNzY2ODE_size_16_color_FFFFFF_t_70 1][]

# 第七章 数学知识 #

## 7.1 数字取整 ##

1.向上bai取整Math.ceil();

举例du：Math.ceil(11.4)=12; Math.ceil(-11.6)=-11;

2.向下取整Math.floor();

举例：Math.floor(11.7)=11;Math.floor(-11.2)=-12;

3.四舍五入Math.round();

顾名思义，zhi四舍五入后取整，其算法为Math.round(x+0.5),即原来的数字加上0.5后再想下取整即可。

## 7.2 math部分API ##

double a = -0.5;
    double pi = Math.PI;
    double e = Math.E;
    System.out.println("a的绝对值为：" + Math.abs(a));
    System.out.println("pi的反余弦值为：" + Math.acos(pi/4));
    System.out.println("a向上取整的值为：" + Math.floor(a));
    System.out.println("a向下取整的值为：" + Math.ceil(a));
    System.out.println("e的自然对数为" + Math.log(e));
    System.out.println("a与0.5中的最大值为：" + Math.max(a,0.5));
    System.out.println("a乘以一个[0,1)随机值为" + Math.random()*a);
    System.out.println("最接近a的long类型值为：" + Math.round(a));
    System.out.println("pi/6的正弦值为：" + Math.sin(pi/6));

## 7.3 排列组合 ##

大数取模时可能会用到：(a/b)%m = (a % (b*m))/b

![在这里插入图片描述][20190618213943191.png]

[https_blog.csdn.net_weixin_43217942_article_details_83043120]: https://blog.csdn.net/weixin_43217942/article/details/83043120
[https_www.cnblogs.com_-maji_p_7123248.html]: https://www.cnblogs.com/-maji/p/7123248.html
[https_blog.csdn.net_weixin_42696192_article_details_102453797]: https://blog.csdn.net/weixin_42696192/article/details/102453797
[https_blog.csdn.net_daoshen1314_article_details_100581136]: https://blog.csdn.net/daoshen1314/article/details/100581136
[https_blog.csdn.net_qq997404392_article_details_78085783]: https://blog.csdn.net/qq997404392/article/details/78085783
[https_www.jianshu.com_p_53cc95a4eea7]: https://www.jianshu.com/p/53cc95a4eea7
[https_blog.csdn.net_q610376681_article_details_89220585_2.5_20TreeSet]: https://blog.csdn.net/q610376681/article/details/89220585#2.5%20TreeSet
[https_blog.csdn.net_qq_39326472_article_details_90751089]: https://blog.csdn.net/qq_39326472/article/details/90751089
[format_png]: /images/20230209/31310b1b60c0416db9d2103247454feb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3E2MTAzNzY2ODE_size_16_color_FFFFFF_t_70]: /images/20230209/a839aa016c514b69a6c527eaac2fa998.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3E2MTAzNzY2ODE_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200714172339555.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3E2MTAzNzY2ODE=,size_16,color_FFFFFF,t_70
[20190618213943191.png]: https://img-blog.csdnimg.cn/20190618213943191.png