一，基本数据类型

1.int,float.double等转换为字符串用 String.valueOf方法

eg：double转换为String

  1. Double dtDouble=12.31354;
  2. String string=String.valueOf(dtDouble);
  3. System.out.println(string);

2.字符串转换为int，float，double等用其引用类型的parse对应的方法

eg：string 转换为double

  1. String string="1.254849";
  2. Double dt1=Double.parseDouble(string);
  3. System.out.println(dt1);

3.double保留两位小数

DecimalFormat为java.text.DecimalFormat

  1. double d = 32.1415926;
  2. //0.00就是两位，0.000就是三位，依此类推
  3. DecimalFormat decimalFormat=new DecimalFormat("0.00");
  4. String d1=decimalFormat.format(d);
  5. System.out.println(d1);//32.14

二，大数运算

1.BigDecimal

如果直接使用double计算，可能会出现以下情况

  1. double t=1.0-2.2*1.0;
  2. System.out.println(t);//-1.2000000000000002

所以double做精确计算时推荐使用BigDecimal

BigDecimal使用教程

  1. import java.math.BigDecimal;
  2.  
  3. public class testDecimal {
  4.     public static void main(String[] args) {
  5.         double d1=0.01;
  6.         double d2=0.02;
  7.         BigDecimal d1BigDec=new BigDecimal(Double.toString(d1));
  8.         BigDecimal d2BigDec=new BigDecimal(Double.toString(d2));
  9.         //加法
  10.         BigDecimal addB=d1BigDec.add(d2BigDec);
  11.         Double add=addB.doubleValue();
  12.         System.out.println(add);//0.03
  13.         //减法
  14.         BigDecimal subB=d1BigDec.subtract(d2BigDec);
  15.         Double sub=subB.doubleValue();
  16.         System.out.println(sub);//-0.01
  17.         //乘法
  18.         BigDecimal mulB=d1BigDec.multiply(d2BigDec);
  19.         Double mul=mulB.doubleValue();
  20.         System.out.println(mul);//2.0E-4
  21.         //除法一
  22.         BigDecimal divB=d1BigDec.divide(d2BigDec);
  23.         Double div=divB.doubleValue();
  24.         System.out.println(div);//0.5
  25.         //除法二（如果有除不尽的，会报异常，需要自己指定保留几位小数）
  26.         //注意这个divide方法有两个重载的方法，一个是传两个参数的，一个是传三个参数的：
  27.         //两个参数的方法：
  28.         //@param divisor value by which this {@code BigDecimal} is to be divided. 传入除数
  29.         //@param roundingMode rounding mode to apply. 传入round的模式
  30.         //三个参数的方法：
  31.         //@param divisor value by which this {@code BigDecimal} is to be divided. 传入除数
  32.         //@param scale scale of the {@code BigDecimal} quotient to be returned. 传入精度
  33.         //@param roundingMode rounding mode to apply. 传入round的模式
  34.         double dt1=2.0;
  35.         double dt2=3.0;
  36.         BigDecimal dt1BigDec=new BigDecimal(Double.toString(dt1));
  37.         BigDecimal dt2BigDec=new BigDecimal(Double.toString(dt2));
  38.         //保留六位小数
  39.         BigDecimal divideB = dt1BigDec.divide(dt2BigDec, 6, BigDecimal.ROUND_HALF_UP);
  40.         double divide = divideB.doubleValue();
  41.         System.out.println(divide);//0.666667
  42.     }
  43. }

除并求余运算

  1. import java.math.BigDecimal;
  2.  
  3. public class Main {
  4.      public static void main(String[] args) {
  5.             BigDecimal amt = new BigDecimal(1001);
  6.             BigDecimal[] results = amt.divideAndRemainder(new BigDecimal(50));
  7.             //商 20
  8.             System.out.println(results[0]);
  9.             //余数1
  10.             System.out.println(results[1]);
  11.         }
  12.  
  13. }

三，数组

1.数组自带的方法

2.操纵数组类Arrays（java.util.Arrays）

sort

升序
  1. int scores[] = new int[]{1,2,3,89,4};
  2. Arrays.sort(scores);
降序

  • Collections为java.util.Collections

  • 不能使用基本类型（int,double, char），如果是int型需要改成Integer，float要改成Float

  1. Integer scores[] = {1,2,3,89,4};
  2. Arrays.sort(scores, Collections.reverseOrder());
自定义规则排序

  • Comparator为java.util.Comparator

  1.  Integer[] arr = {5,4,7,9,2,12,54,21,1};
  2.         //降序
  3.         Arrays.sort(arr, new Comparator<Integer>() {
  4.             public int compare(Integer a, Integer b) {
  5.                 return b-a;
  6.             }
  7.         });
  8.         System.out.println(Arrays.toString(arr));

fill

作用：把数组所有元素都赋值为指定数

  1. int [] scores={12,21,13,24};
  2. Arrays.fill(scores,22);//将数组中所有元素都赋值为22

copyOfRange

作用：将数组指定的范围复制到一个新数组中

  1.         int [] scores1={12,21,13,24};
  2.         int[]scores= Arrays.copyOfRange(scores1,1,3);
  3.         //21,13
  4.         for(int i=0;i<scores.length;i++){
  5.             System.out.println(scores[i]);
  6.         }

toString

作用：将数组内容转换称为字符串

  1. int[] arr = {1,3,5,6};
  2. String s = Arrays.toString(arr);
  3.  //打印字符串，输出内容
  4. System.out.println(s);//[1,3,5,6]

asList

作用：将数组转换为集合

  • 只有是引用类型的才能使用泛型

  1. Integer[] a = {1,2,3,4};
  2. List<Integer> list= Arrays.asList(a);

四，集合

1.集合自带的方法

2.操作集合的类Collections（java.util.Collections）

sort

自定义规则排序
  1. package shuZu;
  2. import java.util.ArrayList;
  3. import java.util.Collections;
  4. import java.util.Comparator;
  5. import java.util.List;
  6.  
  7. public class sort {
  8.     public static void main(String[] args) {
  9.         List<Student> stus = new ArrayList<>();
  10.         Student stu1 = new Student();
  11.         Student stu2 = new Student();
  12.         Student stu3 = new Student();
  13.         Student stu4 = new Student();
  14.         Student stu5 = new Student();
  15.         Student stu6 = new Student();
  16.  
  17.         stu1.setAge(30);
  18.         stu2.setAge(20);
  19.         stu3.setAge(40);
  20.         stu4.setAge(30);
  21.         stu5.setAge(40);
  22.         stu6.setAge(20);
  23.  
  24.         stu1.setNum(1);
  25.         stu2.setNum(2);
  26.         stu3.setNum(3);
  27.         stu4.setNum(4);
  28.         stu5.setNum(5);
  29.         stu6.setNum(6);
  30.  
  31.         stu1.setName("张三");
  32.         stu2.setName("李四");
  33.         stu3.setName("王五");
  34.         stu4.setName("赵六");
  35.         stu5.setName("陈七");
  36.         stu6.setName("周八");
  37.  
  38.         stus.add(stu1);
  39.         stus.add(stu2);
  40.         stus.add(stu3);
  41.         stus.add(stu4);
  42.         stus.add(stu5);
  43.         stus.add(stu6);
  44.  
  45.         Collections.sort(stus, new Comparator<Student>() {
  46.  
  47.             @Override
  48.             public int compare(Student s1, Student s2) {
  49.                 int flag;
  50.                 // 首选按年龄升序排序
  51.                 flag = s1.getAge() - s2.getAge();
  52.                 if (flag == 0) {
  53.                     // 再按学号升序排序
  54.                     flag = s1.getNum() - s2.getNum();
  55.                 }
  56.                 return flag;
  57.             }
  58.         });
  59.  
  60.         System.out.println("年龄       学号       姓名  ");
  61.         for (Student s : stus) {
  62.             System.out.println(s.getAge() + "   " + s.getNum() + "   " + s.getName());
  63.         }
  64.     }
  65. }
  66. class Student{
  67.     int age;
  68.     int num;
  69.     String name;
  70.  
  71.     public int getAge() {
  72.         return age;
  73.     }
  74.  
  75.     public void setAge(int age) {
  76.         this.age = age;
  77.     }
  78.  
  79.     public int getNum() {
  80.         return num;
  81.     }
  82.  
  83.     public void setNum(int num) {
  84.         this.num = num;
  85.     }
  86.  
  87.     public String getName() {
  88.         return name;
  89.     }
  90.  
  91.     public void setName(String name) {
  92.         this.name = name;
  93.     }
  94. }

将集合翻转并将结果都添加到另外一个集合（reverse(list)，addAll(list)）

  1. //将tem的每位数字加入集合list，将list倒序，将list全添加到result集合里面
  2. private void tc(int tem, List<Integer> result) {
  3.         // TODO Auto-generated method stub
  4.         List<Integer>list=new ArrayList<>();
  5.         while(tem!=0) {
  6.             int t=tem%10;
  7.             tem/=10;
  8.             list.add(t);
  9.         }
  10.         Collections.reverse(list);
  11.         result.addAll(list);
  12.  
  13.     }

补充：hashMap按值排序

输入

第一行 输入n个字符串

其余n行 ：n个字符串

输出每个字符串从大到小出现次数

格式 出现次数 - 字符串

eg:

  1. 5
  2. 2 -1 -1 22
  3. 1 11 66 0
  4. 1 28 74 35
  5. 3 35 28 7
  6. 2 -1 -1 22

实现代码

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.Comparator;
  4. import java.util.HashMap;
  5. import java.util.List;
  6. import java.util.Map;
  7. import java.util.Map.Entry;
  8. import java.util.Scanner;
  9. public class Main {
  10.     public static void main(String[] args) {
  11.         Map<String, Integer>map=new HashMap<>();
  12.         Scanner sca=new Scanner(System.in);
  13.         int n=sca.nextInt();
  14.         sca.nextLine();
  15.         for(int i=0;i<n;i++) {
  16.             String str=sca.nextLine();
  17.             int num=map.getOrDefault(str, 0)+1;
  18.             map.put(str, num);
  19.         }
  20.         List<Map.Entry<String, Integer>>list=new ArrayList<>();
  21.         for(Map.Entry<String, Integer>mv:map.entrySet()) {
  22.             list.add(mv);
  23.         }
  24.         Collections.sort(list,new Comparator<Map.Entry<String, Integer>>() {
  25.  
  26.             @Override
  27.             public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
  28.                 // TODO Auto-generated method stub
  29.                 return o2.getValue()-o1.getValue();
  30.             }
  31.         });
  32.         System.out.println();
  33.         for(int i=0;i<list.size();i++) {
  34.             Map.Entry<String, Integer> mvEntry=list.get(i);
  35.             String key=mvEntry.getKey();
  36.             Integer value=mvEntry.getValue();
  37.             System.out.println(value +" - "+ key);
  38.         }
  39.     }
  40. }

输出

  1. 2 - 2 -1 -1 22
  2. 1 - 1 28 74 35
  3. 1 - 1 11 66 0
  4. 1 - 3 35 28 7

补充：HashSet的遍历

  1. import java.util.HashSet;
  2. import java.util.Iterator;
  3. import java.util.Set;
  4. public class Main {
  5. public static void main(String[] args) {
  6.     //HashSet没有get方法，所以只能通过加强for循环或迭代器实现遍历
  7.     Set<Integer>set=new HashSet<>();
  8.     set.add(1);
  9.     set.add(2);
  10.     set.add(9);
  11.     set.add(2);
  12.     set.add(7);
  13.     //加强for循环
  14.     for(Integer s:set) {
  15.         System.out.println(s);
  16.     }
  17.     //迭代器
  18.     Iterator<Integer> itor=set.iterator();
  19.     while(itor.hasNext()) {
  20.         System.out.println(itor.next());
  21.     }
  22. }
  23. }

五，字符串

toCharArray

作用：字符串转换为字符数组

  1. String str="Hello";
  2. char[] chars = str.toCharArray();

其它方法

创建实例：

String str = new String(); str = "String";

1、char charAt(int index)：返回指定索引位置的字符

  1.  　　System.out.println(str.charAt(0));
  2.  　　//return "S";

2、String substring(int beginIndex)：返回指定起始位置至字符串末尾的字符串

  1.  　　System.out.println(str.substring(1));
  2. 　//return "tring"
String substring(int beginIndex, int endIndex)：返回指定起始位置（含）到结束位置（不含）之间的字符串
  1.      System.out.println(str.substring(1, 3));
  2.     //return "tr";

3、一个或多个空格分割字符串

  1. String的split方法支持正则表达式；

  2. 正则表达式\s表示匹配任何空白字符，+表示匹配一次或多次。

  1. String [] arr = str.split("\\s+");
  2. for(String ss : arr){
  3.     System.out.println(ss);
  4. }

4、int indexOf(String str)：返回指定字符串的索引位置

  1.  　　System.out.println(str.indexOf("i"));
  2.  　　//return "3";
  3.  
  4.  　　System.out.println(str.indexOf("ing"));
  5.  　　//return "3";
int indexOf(String str, int fromIndex)：返回从指定索引位置fromIndex开始的str的索引位置,如果没有返回-1
  1. System.out.println(str.indexOf("ing", 2));
  2. 　//return "3";

5、String replace(CharSequence oldString, CharSequence newString): 用newString替换字符串中的oldString

  1. 　System.out.println(str.replace("g", "gs"));
      //return "Strings";

6、String trim()：返回一个去除两头空格的新字符串

  1.  　　String str1 = new String();
  2.  　　str1 =  " "+"string"+" ";
  3.  　　System.out.println(str1.length());
  4.  　　//return "8"
  5.  　　str1 = str1.trim();
  6.  　　System.out.println(str.length());
  7.  　　//return "6"

7、String[ ] split(String regex)：指定正则表达式分隔符，返回一个字符串数组

  1.  　　String str2 = new String();
  2.  　　str2 = "A/B/C";
  3.  　　String s[] = str2.split("/");
  4.  　　System.out.println("s[0] = "+s[0]);
  5.  　　//return"A"
  6.  　　for(String ss: s) {
  7.  　　System.out.print(ss+" ");
  8.  　　}
  9.  　　//return"A B C"
　String[ ] split(String regex, int limit)：指定正则表达式分隔符regex和分隔份数limit，返回一个字符串数组　
  1.  　　String str2 = new String();
  2.  　　str2 = "A/B/C";
  3.  　　String s[] = str2.split("/", 2);
  4.  　　for(String ss: s) {
  5.  　　System.out.print(ss+" ");
  6.  　　}
  7.  　　//return"A B/C"

注意： . 、 | 和 * 等转义字符，必须得加 \

　　注意：多个分隔符，可以用 | 作为连字符

8、*String toLowerCase()：转换为小写字母* *String toUpperCase()：转换为大写字母*

9、boolean startsWith(String prefix)：如果字符串以prefix开头返回true，否则返回false 　 boolean endsWith(String suffix)：如果字符串以suffix结尾返回true，否则返回false

10、boolean equals(Object other)：如果字符串与other相等返回true，否则返回false 　 boolean equalsIgnoreCase(String other)：如果字符串与other相等（忽略大小写）返回true，否则返回false

字符串查找 indexOf

补充：字符判断方法

  1. public class Main {
  2. public static void main(String[] args) {
  3.     char c = 'a';
  4.     Boolean arr[]=new Boolean[6];
  5.     arr[0]=Character.isDigit(c);//判断字符是否数字
  6.     arr[1]=Character.isLetter(c);//判断字符是否字母
  7.     arr[2]=Character.isLetterOrDigit(c);//判断字符是否字母或数字
  8.     arr[3]=Character.isLowerCase(c);//判断字符是否小写字母
  9.     arr[4]=Character.isUpperCase(c);//判断字符是否大写字母
  10.     arr[5]=Character.isWhitespace(c);//判断字符是否空格[/size]
  11.     for(int i=0;i<arr.length;i++) {
  12.         System.out.println(arr[i]);
  13.     }
  14. }

六，队列

  1. import java.util.LinkedList;
  2. import java.util.Queue;
  3.  
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         //add()和remove()方法在失败的时候会抛出异常(不推荐)
  7.         Queue<String> queue = new LinkedList<String>();
  8.         //添加元素
  9.         queue.offer("a");
  10.         queue.offer("b");
  11.         queue.offer("c");
  12.         queue.offer("d");
  13.         queue.offer("e");
  14.         for(String q : queue){
  15.             System.out.println(q);
  16.         }
  17.         System.out.println("===");
  18.         System.out.println("poll="+queue.poll()); //返回第一个元素，并在队列中删除
  19.         for(String q : queue){
  20.             System.out.println(q);
  21.         }
  22.         System.out.println("===");
  23.         System.out.println("element="+queue.element()); //返回第一个元素
  24.         for(String q : queue){
  25.             System.out.println(q);
  26.         }
  27.         System.out.println("===");
  28.         System.out.println("peek="+queue.peek()); //返回第一个元素
  29.         for(String q : queue){
  30.             System.out.println(q);
  31.         }
  32.     }

Queue 中 element() 和 peek()都是用来返回队列的头元素，不删除。

在队列元素为空的情况下，element() 方法会抛出NoSuchElementException异常，peek() 方法只会返回 null

add()和offer()方法的区别是

区别：两者都是往队列尾部插入元素，不同的时候，当超出队列界限的时候，add（）方法是抛出异常让你处理，而offer（）方法是直接返回false

所以

添加元素推荐用offer()，返回并删除头元素用 poll()，只返回头元素用peek()

补充：优先级队列

以leecode题目连接所有点的最小费用为例

题目描述

给你一个points 数组，表示 2D 平面上的一些点，其中 points[i] = [xi, yi] 。

连接点 [xi, yi] 和点 [xj, yj] 的费用为它们之间的 曼哈顿距离 ：|xi - xj| + |yi - yj| ，其中 |val| 表示 val 的绝对值。

请你返回将所有点连接的最小总费用。只有任意两点之间 有且仅有 一条简单路径时，才认为所有点都已连接。

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/min-cost-to-connect-all-points 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

  1. import java.util.Comparator;
  2. import java.util.PriorityQueue;
  3. import java.util.Queue;
  4.  
  5. public class Solution {
  6.  
  7.     public Queue<EDGE> priorityQueue = new PriorityQueue<EDGE>(new Comparator<EDGE>() {
  8.  
  9.         @Override
  10.         public int compare(EDGE o1, EDGE o2) {
  11.             // TODO Auto-generated method stub
  12.             return o1.quanZhi - o2.quanZhi;
  13.         }
  14.     });
  15.  
  16.     public int getQuanZhi(int xi, int yi, int xj, int yj) {
  17. //        |xi - xj| + |yi - yj|
  18.         return Math.abs(xi - xj) + Math.abs(yi - yj);
  19.     }
  20.  
  21.     public int vic[];
  22.  
  23.     public int minCostConnectPoints(int[][] points) {
  24.         vic = new int[points.length + 1];
  25.         // 以节点0为起点开始搜索
  26.         vic[0] = 1;
  27.         int size = 1;
  28.         int result = 0;
  29.         // 将与节点0相连的节点加入优先级队列
  30.         for (int i = 1; i < points.length; i++) {
  31.             priorityQueue.offer(new EDGE(0, i, getQuanZhi(points[0][0], points[0][1], points[i][0], points[i][1])));
  32.         }
  33.         while (!priorityQueue.isEmpty()) {
  34.             EDGE edge = priorityQueue.poll();
  35.             int end = edge.end;
  36.             // 如果该节点以及访问过，则continue
  37.             if (vic[end] == 1) {
  38.                 continue;
  39.             }
  40.             result += edge.quanZhi;
  41.             // 节点个数加一
  42.             size++;
  43.             if (size == points.length) {
  44.                 break;
  45.             }
  46.             vic[end] = 1;
  47.             // 以该节点来将其周围节点加入进去
  48.             for (int i = 0; i < points.length; i++) {
  49.                 priorityQueue.offer(new EDGE(end, i, getQuanZhi(points[end][0], points[end][1], points[i][0], points[i][1])));
  50.             }
  51.         }
  52.         return result;
  53.     }
  54. }
  55.  
  56. class EDGE {
  57.     public int start;
  58.     public int end;
  59.     public int quanZhi;
  60.  
  61.     public EDGE(int start, int end, int quanZhi) {
  62.         this.start = start;
  63.         this.end = end;
  64.         this.quanZhi = quanZhi;
  65.     }
  66. }

七，栈

  1. import java.util.Stack;
  2. public class Main {
  3.     public static void main(String[] args) {
  4.         Stack<Integer>stack=new Stack<>();
  5.         //入栈
  6.         stack.push(3);
  7.         stack.push(5);
  8.         stack.push(2);
  9.         //出栈
  10.         while(!stack.isEmpty()) {
  11.             Integer tInteger=stack.pop();
  12.             System.out.print(tInteger);
  13.         };
  14.     }
  15. }

八，操作日期的类GregorianCalendar

以蓝桥杯任意年月输出日历为例

题目描述

已知2007年1月1日为星期一。 设计一函数按照下述格式打印2007年以后（含）某年某月的日历，2007年以前的拒绝打印。 为完成此函数，设计必要的辅助函数可能也是必要的。其中输入为年分和月份。

注意：短线“-”个数要与题目中一致，否则系统会判为错误。

样例输入

  1. 2010 9

样例输出

  1. ---------------------
  2.  Su Mo Tu We Th Fr Sa
  3. ---------------------
  4.            1  2  3  4
  5.   5  6  7  8  9 10 11
  6.  12 13 14 15 16 17 18
  7.  19 20 21 22 23 24 25
  8.  26 27 28 29 30
  9. ---------------------

代码实现

  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  4. import java.util.Calendar;
  5. import java.util.GregorianCalendar;
  6. import java.util.StringTokenizer;
  7.  
  8. public class Main {
  9.     static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
  10.     static StringTokenizer stringTokenizer = new StringTokenizer("");
  11.  
  12.     static String nextLine() throws IOException {
  13.         return bufferedReader.readLine();
  14.     }
  15.  
  16.     static String next() throws IOException {
  17.         while (!stringTokenizer.hasMoreTokens()) {
  18.             stringTokenizer = new StringTokenizer(bufferedReader.readLine());
  19.         }
  20.         return stringTokenizer.nextToken();
  21.     }
  22.  
  23.     static int nextInt() throws NumberFormatException, IOException {
  24.         return Integer.parseInt(next());
  25.     }
  26.  
  27.     public static void main(String[] args) throws NumberFormatException, IOException {
  28.         int yera = nextInt();
  29.         int mouth = nextInt();
  30.         //mouth是从0到11的
  31.         //创建日期对象，将年月日（1）放进去
  32.         GregorianCalendar gregorianCalendar = new GregorianCalendar(yera,mouth-1,1);
  33.         //获取该月天数
  34.         int days=gregorianCalendar.getActualMaximum(Calendar.DAY_OF_MONTH);
  35.         //获取该月第一天是星期几,需要减一
  36.         int xq=gregorianCalendar.get(Calendar.DAY_OF_WEEK)-1;
  37.         System.out.println("---------------------");
  38.         System.out.println(" Su Mo Tu We Th Fr Sa");
  39.         System.out.println("---------------------");
  40.         //输入前面空格
  41.         int t=0;
  42.         for(int i=0;i<xq;i++) {
  43.             System.out.print("   ");
  44.             t++;
  45.         }
  46.         for(int i=1;i<=days;i++) {
  47.             System.out.printf("%3d", i);
  48.             t++;
  49.             if(t%7==0) {
  50.                 System.out.println();
  51.             }
  52.         }
  53.         if(t%7!=0) {
  54.             System.out.println();
  55.         }
  56.         System.out.println("---------------------");
  57.  
  58.     }
  59. }

九，优化io流（不用scanner）

  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  4. import java.util.StringTokenizer;
  5.  
  6. public class Main {
  7.  
  8.     static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
  9.     static StringTokenizer tokenizer = new StringTokenizer("");
  10.  
  11.     static String nextLine() throws IOException {// 读取下一行字符串
  12.         return reader.readLine();
  13.     }
  14.  
  15.     static String next() throws IOException {// 读取下一个字符串
  16.         while (!tokenizer.hasMoreTokens()) {
  17.             tokenizer = new StringTokenizer(reader.readLine());
  18.         }
  19.         return tokenizer.nextToken();
  20.     }
  21.  
  22.     static int nextInt() throws IOException {// 读取下一个int型数值
  23.         return Integer.parseInt(next());
  24.     }
  25.  
  26.     static double nextDouble() throws IOException {// 读取下一个double型数值
  27.         return Double.parseDouble(next());
  28.     }
  29.  
  30.     public static void main(String[] args) throws IOException {
  31.        String str= next();
  32.        String str1= next();
  33.        String str2= next();
  34.        String str3= next();
  35.        String str4= next();
  36.        System.out.println(tokenizer.toString());
  37.     }
  38. }

java 竞赛常用方法的更多相关文章

  1. java Map常用方法封装

      java Map常用方法封装 CreationTime--2018年7月16日15点59分 Author:Marydon 1.准备工作 import java.util.HashMap; impo ...

  2. Rhythmk 一步一步学 JAVA (20) JAVA enum常用方法

    JAVA 枚举定义常用方法: 1.static Enum valueOf(Class enum,String name) 返回指定name的枚举类型 2.Static Enum values[] 返回 ...

  3. Java线程常用方法详解

    线程的常用方法 1．start() : 线程调用该方法将启动线程,使之从新建状态进入就绪队列排队,一旦轮到它来享用CPU资源时,就可以脱离创建它的线程独立开始自己的生命周期了. 2．run(): Th ...

  4. Java多线程常用方法的使用

    Java多线程的常用方法基本分为:获取当前线程的操作,线程休眠sleep()方法,线程让步yield()方法,等待其他线程终止join()方法,线程停止的一系列方法. 一.获取当前线程的操作   1. ...

  5. Java后台常用方法（更新中）

    String字符串 API文档地址:中文 英文 String类在java.lang包中,java使用String类创建字符串变量,字符串变量属于对象. String类对象创建后不能修改,String变 ...

  6. Java 集合常用方法锦集

    Java集合非常的重要,尤其在业务中,如果你在熟练的使用Java数据结果的集合工作,将会大大的提高工作效率,减少代码量. 1.集合的互换 1.1 Map转Set Map<Integer, Str ...

  7. JAVA数据转换常用方法

    时间格式化与运算 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Calendar calendar=sdf. ...

  8. java System 常用方法

    一.System.currentTimeMillis() 获取系统当前时间,毫秒 二.System.getProperty Java.version Java 运行时环境版本 java.vendor ...

  9. java Arrays常用方法

    1. 简介 Arrays类包含用于操作数组的各种方法(例如排序和搜索).此类还包含一个静态工厂,允许将数组视为列表. 如果指定的数组引用为null,则此类中的方法都抛出NullPointerExcep ...

随机推荐

  1. 6月21日 Django ORM那些相关操作(表关联、聚合查询和分组查询)

    一.ForeignKey操作 正向查找 对象查找(跨表) 语法: 对象.关联字段.字段   示例: book_obj = models.Book.objects.first() # 第一本书对象 pr ...

  2. el-upload用form的方式多文件上传的方法

    使用el-upload组件遇到的坑. 1.第一种感觉最好,首先多个文件是一个http请求,另外还可以传除文件外其他的参数,但是没有进度条了. 发送请求的部分没有注释的部分是我分装了调后台的api,注释 ...

  3. matplotlib字体

    matplotlib官方文档 https://matplotlib.org/stable/gallery/index.html 使用以下代码查看 import matplotlib.pyplot as ...

  4. java LinkedList （详解）

    Java 链表(LinkedList) 一.链表简介 1.链表 (Linked List) 是一种常见的基础数据结构,是一种线性表,但是链表不会按线性表的顺序存储数据,而是每个节点里存到下一个节点的地 ...

  5. ChIP-seq技术介绍｜易基因

    大家好,这里是专注表观组学十余年,多组学科研服务领跑者的易基因. 染色质免疫沉淀后测序(ChIP seq)是一种针对DNA结合蛋白.组蛋白修饰或核小体的全基因组分析技术.由于二代测序技术的巨大进步,C ...

  6. CAS 的问题 ？

    1.CAS 容易造成 ABA 问题 一个线程 a 将数值改成了 b,接着又改成了 a,此时 CAS 认为是没有变化,其实 是已经变化过了,而这个问题的解决方案可以使用版本号标识,每操作一次 versi ...

  7. memcached 是如何做身份验证的？

    没有身份认证机制!memcached 是运行在应用下层的软件(身份验证应该是应用 上层的职责).memcached 的客户端和服务器端之所以是轻量级的,部分原因就 是完全没有实现身份验证机制.这样,m ...

  8. Mybatis入门程序（一）

    1.入门程序实现需求 根据用户id查询一个用户信息 根据用户名称模糊查询用户信息列表 添加用户(二) 更新用户(二) 删除用户(二) 2.引入Mybatis所需 jar 包(Maven工程) < ...

  9. ArrayList、LinkedList、Vector、Array

    ArrayList 本质是一个数组. 优势:追加元素到数组末尾的时候速度快,同时检索元素的速度也快. 劣势:如果要插入一个元素到数组之间慢:如果要追加的元素数量多于数组的容量,则需要频繁扩容使用Arr ...

  10. input 弹起数字键盘的那些坑

    input ios 踩的大坑 前言:最近有个需求要将全平台的交易密码由原来的 6-16位 复杂密码改为6位纯数字交易密码,涉及到非常多的业务场景,但修改起来也无非两种:设置交易密码,使用交易密码 设置 ...