Java刷题的常用代码

Piggytuotuo

已于 2023-04-12 13:24:39 修改

阅读量335

点赞数

分类专栏： Java基础算法题文章标签： java 开发语言

于 2023-04-12 13:16:21 首次发布

本文链接：https://blog.csdn.net/qq_42521345/article/details/130104645

版权

算法题同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

Java基础

1 篇文章 0 订阅

订阅专栏

在线文档

https://www.matools.com/api/java8

从键盘输入

Scanner sc =new Scanner(System.in);
Integer a=sc.nextInt();

int、Integer、Double

int为基本数据类型，Integer为int对应的包装类。
在范型中使用Integer

HashMap<String,Integer> mymap=new HashMap<String,Integer>();

判断两个int是否相等或Integer与int是否相等，用==
判断两个Integer是否相等用.equals()

System.out.println(m.peekFirst()==q.peek()); //not always true
System.out.println(m.peekFirst().equals(q.peek()));//True
int ans=q.peek();
System.out.println(m.peekFirst()==ans);//True

//int转double
Double v=Double.valueOf(intvalue);
//double转Int
Integer a=(int)doublevalue; //强制转换默认舍弃小数点后的数 
Integer b=(int)Math.round(doublevalule);//Math.round四舍五入                
//按格式输出
String.format("%5d",Integer.valueof("3"));
String.format("%.2f",Double.valueof("3"));
//四舍五入并保留小数
BigDecimal bd=new BigDecimal("133.227878");
bd=bd.setScale(5,RoundingMode.HALF_UP);//RoundingMode.UP Roundingode.DOWN

最大值最小值

//Float Double Byte Character Short Integer Long
Imax = Integer.MAX_VALUE;
Imin = Integer.MIN_VALUE;

Math.max((int)a,(int)b);
Math.min((int)a,(int)b);

排序

Arrays.sort()对数组排序，重载了四类方法
● sort(T[] a)：对指定T型数组按数字升序排序。
● sort(T[] a,int formIndex, int toIndex)：对指定T型数组的指定范围按数字升序排序。
● sort(T[] a, Comparator<? supre T> c): 根据指定比较器产生的顺序对指定对象数组进行排序。
● sort(T[] a, int formIndex, int toIndex, Comparator<? supre T> c): 根据指定比较器产生的顺序对指定对象数组的指定对象数组进行排序。

Comparator的compare方法默认从小到大（o1的优先级高于o2）：
若参数o1<参数o2,返回负值，o1=o2返回0，o1>o2返回正值。

//Arrays.sort只支持对包装类进行自定义排序
Integer[] a=new Integer[n];

//比较器写法
//降序排序需要自定义comparator
Comparator cmp = new MyComparator();
Arrays.sort(a, cmp);

class MyComparator implements Comparator<Integer> {
    //如果o1小于o2，我们就返回正值，如果o1大于o2我们就返回负值，
    //这样颠倒一下，就可以实现反向排序了
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2-o1;
    }
}

//lamda写法
Arrays.sort(a, (n1,n2)->{
    return n2 - n1;
});

Collections.sort()对List排序
● sort(List list, Comparator<? super T> c):根据指定比较器产生的顺序对指定List进行排序。

字符串

String转int/long

int a = Integer.parseInt(string);
long la = Long.parseLong(string);

Int转String

String s = String.valueOf(a);
String s = a + "";

//int转不同进制的String
int i = 2023;
String s = Integer.toBinaryString(i);
String s = Integer.toOctalString(i);
String s = Integer.toString(i);
String s = Integer.toHexString(i);

String

String s = "asdefgasdefg";
for(int i = 0; i < s.length(); i++){
    char c = s.charAt(i);
}
s.indexOf('s') //retrun 1
s.indexof('s',2) //return 7
s.lastIndexOf('s') //return 7
s.lastIndexOf('s',6)//return 1
string[] ss = s.split(String a);//以字符串a分割字符串
String s = s.substring((int)start,(int)end)//[start,end)

//String与char数组的转换
char[] cs = s.toCharArray();
String s = new String(cs);

String s = s.toLowerCase();
String s = s.toUpperCase();
String s = s.trim(); //去掉字符串两端多余的空格
String s = String.valueOf(object);
boolean equal=s1.equals(s2);
//string左补0
String a=String.format("%6d",Integer.valueof("123"))//输出000123

//字典顺序比较两个String
int res = a.compareTo(b);//a<b,res<0;a>b,res>0

StringBuilder & StringBuffer

速度：StringBuilder > StringBuffer > String
线程不安全线程安全常量

StringBuilder sb = new StringBuilder("String");
sb.append("");
sb.reverse();
sb.delete((int)start,(int)end); //[start,end)
sb.deleteCharAt(int index);
sb.insert((int)offset,"String");
sb.toString();
sb.setCharAt((int)index,(char)c);

//翻转字符串
StringBuffer sb = new StringBuffer("TestString");
sb.reverse();
System.out.println(sb.toString());

字符串组

String[] a = new String[100];
Arrays.sort(a);
//与list转换  List<Integer> 和 int[] 因类型不同不可直接转换
List<String> list = Arrays.asList(a);
String[] b = (String[])list.toArray(new String[size]);
//复制
String[] c = Arrays.copyOfRange(String[] original,(int)start,(int)to)//[start,to)
//填充
Arrays.fill(a,"fill");

JDK1.8集合框架

Collection接口（一维集合）

Collection接口是Set,List,Queue接口的父接口
//Collection
add(Object o);
addAll(Collection c);
clear();
contains(Object o);
remove(Object o);
size();
toArray();
Collections.sort(Collection c);
Collections.reverse(Collection c);

一维集合 set list queue

//Set 不允许重复
HashSet<Object> set = new HashSet<>();
set.add(Object o);
set.contains(Object o);
set.remove(Object o);

//List  有序集合，具有和索引有关的操作
List<Object> list = new ArrayList<>();
list.add((int)index,Object o);
list.get((int)index);
list.remove((int)index);
list.indexOf(Object o);
list.subList(int start,int end); [start,end);
//list转array
list1.stream().mapToInt(Integer::valueOf).toArray();
//遍历1
for(Integer t:res) {
	System.out.println(t);
}
//遍历2
Iterator it=res.iterator();
while(it.hasNext()){
	System.out.println(it.next());
}
                                  
//Stack(LIFO)
Stack<Object> s = new Stack<>();
s.pop();//返回Object
s.peek();//返回Object
s.push(Object o);//返回Object
                                  
//Queue(FIFO)
Queue<Object> q = new LinkedList<>();
q.offer(Object o);
q.peek();
q.poll();

List转int数组

//Arraylist转int[]
//转为stream--intStream-调用toArray转为int[]
List<Integer> a = new ArrayList<Integer>();
int[] res_a = a.stream().mapToInt(Integer::valueOf).toArray();

//ArrayList转int[][]
List<int[]> b = new ArrayList<int[]>();
int[][] res_b = b.toArray(new int[0][]);

//使用IntStream生成array 
//InStream接口中的静态方法：通过接口名调用。range 开区间 rangeclosed闭区间
int[] res = IntStream.rangeClosed(0, 5).toArray();//[0,1,2,3,4,5]
List组
//长度为n的数组，每个元素是一个list
List<Integer>[] a = new ArrayList[n];
for(int i = 0; i < n; i++) {
    a[i] = new ArrayList<Integer>();
}

# Map接口（二维集合）

HashTable，此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。
HashMap,基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）
LinkedHashMap，Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序，为插入顺序。
TreeMap，基于红黑树，该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。

Map<String,String> map = new HashMap<>();
map.put("key","value");
map.getOrDefault("key","default");//if(map.containsKey("key")) return "value" else return "default"
map.get("key"); //return "value";
map.containsKey("key");
for(String s : map.keySet()){
    map.get(s);//return value;
}
for(Map.Entry<String,String> entry : map.entrySet()){
    entry.getKey();
    entry.getValue();
}

求余

先忽略符号计算，最后判断符号（异号为－，同号为＋）

位运算

异或^
if((n&1)==1) ==的优先级高于&，因此必须加括号
位运算实现加法：异或保留与进位，与为空时就返回
移位运算符

System.out.println(8 << 2); //32
//有符号右移，高位正数补0，负数补1
//-1(11111111 11111111 11111111 11111111) 右移1位(01111111 11111111 11111111 11111111)
//的结果是-1(11111111 11111111 11111111 11111111)
System.out.println(-1 >> 1);// -1
//无符号右移，高位补0
//-1(11111111 11111111 11111111 11111111) 右移1位(01111111 11111111 11111111 11111111)
//的结果是2147483647(Integer.MAX_VALUE)(01111111 11111111 11111111 11111111)
System.out.println(-1 >>> 1);

大数（大于Double）

运算

import java.math.BigDecimal;

public class test {
    public static void main(String[] args) {
    	BigDecimal mybign=new BigDecimal(10);
    	BigDecimal res_pow=mybign.pow(10);
    	BigDecimal res_mul=mybign.multiply(new BigDecimal(10));
    	BigDecimal res_dev=mybign.divide(new BigDecimal(10));
    	BigDecimal res_rem=mybign.divideAndRemainder(new BigDecimal(10))[1];
    	System.out.println(res_pow.doubleValue()+" "+res_mul.intValue());
    	System.out.println(res_dev.intValue()+" "+res_rem.intValue());
	}
}

进制转换

import java.math.BigInteger;
BigInteger a=new BigInteger(s,16);
String b=a.toString(8);