java算法比赛语法查缺补漏

记住书写的格式，与leetcode差异较大，
该import的要import，import java.util.Scanner;没有提示要自己记住import什么
类名是Main,public class Main
方法名为main(String[] args)

比赛是设置代码补全https://blog.csdn.net/qq_37935670/article/details/79770658

数据类型的范围

int的取值范围为： -2^31——231-1，即-2147483648——2147483647
常超出范围
Integer.parseInt(str)
String：
1.返回Long包装类型：
String str = “aaa”;
long l = Long.parseLong([str]);
2.返回long基本数据类型：
String str = “aaa”;
long l = Long.valueOf("str ").longValue();

int :
1.返回long基本数据类型：
int a = 1;
long b = (int)a;
2.返回Long包装类型：
int a = 1;
Long b = a.longValue();

Java BigInteger用法详解

字符串相关操作

注意字符串之间的相等比较用equal
将字符串转化为字符数组：
public static void main(String[] args) {
String line = “abcdefg”;
char[] chs=line.toCharArray();
System.out.println(Arrays.toString(chs));
}
substring
str＝str.substring(int beginIndex);截取掉str从首字母起长度为beginIndex的字符串，将剩余字符串赋值给str；

str＝str.substring(int beginIndex，int endIndex);截取str中从beginIndex开始至endIndex结束时的字符串，并将其赋值给str;

容器类相关

Object
Iterable(可迭代接口)
Collection（容器接口）
List（列表）
LinkedList（链表）
ArrayList（数组列表）
Set（集合）
HashSet（哈希集合）
SortedSet（有序集合）
Map（映射接口）
HashMap（哈希映射）
SortedMap（有序映射）
TreeMap（树映射）
Iterator（迭代器接口）
ListIterator（列表迭代器接口）

以下重点记录经常用到的一些类的方法

Map

https://www.jianshu.com/p/c093ceb518cf

for循环

遍历数组的简单方式

/* 建立一个数组 */
int[] integers = {1， 2， 3， 4};

/* 开始遍历 /
for (int i : integers) {
System.out.println(i); / 依次输出“1”、“2”、“3”、“4” */
}
遍历Collection的简单方式

/* 建立一个Collection */
String[] strings = {“A”， “B”， “C”， “D”};
Collection list = java.util.Arrays.asList(strings);

/* 开始遍历 /
for (Object str : list) {
System.out.println(str); / 依次输出“A”、“B”、“C”、“D” */
}
这里所用的for循环，则会在编译期间被看成是这样的形式：

遍历Collection的简单方式的等价代码

/* 建立一个Collection */
String[] strings = {“A”， “B”， “C”， “D”};
Collection stringList = java.util.Arrays.asList(strings);

/* 开始遍历 /
for (Iterator 变量名乙 = list.iterator(); 变量名乙.hasNext()😉 {
Object str = 变量名乙.next();
System.out.println(str); / 依次输出“A”、“B”、“C”、“D” */
}

数组

//检查数组是否包含某个值的方法
将数组压入Collection类型中，首先要将数组元素遍历一遍，然后再使用集合类做其他操作，效率低不建议使用

    //使用List
public static boolean useList(String[] arr,String targetValue){
    return Arrays.asList(arr).contains(targetValue);
}
//使用Set
public static boolean useSet(String[] arr,String targetValue){
    Set<String> set=new HashSet<String>(Arrays.asList(arr));
    return set.contains(targetValue);
}
//使用循环判断
public static boolean useLoop(String[] arr,String targetValue){
    for(String s:arr){
        if(s.equals(targetValue))
            return true;
        }  
        return false;
    }

需要引入import java.util.Arrays;

//查找有序数组中是否包含某个值的用法
public static boolean useArraysBinarySearch(String[] arr,String targetValue){
    int a=Arrays.binarySearch(arr, targetValue);
    if(a>0)
        return true;
    else
        return false;
}

动态数组的使用 https://www.imooc.com/article/13654

jdk1.6 栈和队列的使用

队列

import java.util.*;
import java.util.LinkedList;
import java.util.Queue;
首先引入相关包
Queue q=new LinkedList();
去队头
q.poll();
队尾加元素
q.offer(x);
判断有没有元素
q.contains(x)；

优先队列

优先队列的作用是能保证每次取出的元素都是队列中权值最小的（Java的优先队列每次取最小元素，C++的优先队列每次取最大元素）
https://www.cnblogs.com/CarpenterLee/p/5488070.html

降序快速排序

public class Sort {  
     public static void main(String[] args){  
         int[] arr={60,55,48,37,10,90,84,36};  
         int len=arr.length;     
         quickSort(arr,0,len-1);  
         System.out.println("降序快排后----->"+Arrays.toString(arr));  
     }         
     public static  void quickSort(int[] arr,int high,int low){   
         int i,j,temp;  
         i=high;//高端下标  
         j=low;//低端下标  
         temp=arr[i];//取第一个元素为标准元素。  
           
         while(i<j){//递归出口是 low>=high  
               while(i<j&&temp>arr[j])//后端比temp小，符合降序，不管它，low下标前移
            	   j--;//while完后指比temp大的那个
               if(i<j){
            	   arr[i]=arr[j];
            	   i++;
               }
               while(i<j&&temp<arr[i])
            	   i++;
               if(i<j){
            	   arr[j]=arr[i];
            	   j--;
               }
         }//while完，即第一盘排序  
         arr[i]=temp;//把temp值放到它该在的位置。  
      
         if(high<i) //注意，下标值	 
        	 quickSort(arr,high,i-1);//对左端子数组递归  
         if(i<low)  //注意，下标值
             quickSort(arr,i+1,low);//对右端子数组递归  ；对比上面例子，其实此时i和j是同一下标!!!!!!!!!!!!!
  
     }  
}