跳到主要内容

蓝桥杯复习

输入输出​

输入​

Scanner sc = new Scanner(System.in);

例：

  • 输入值
int a = sc.nextInt();
double b = sc.nextDouble();
long c = sc.nextLong();
  • 输入字符串
String s1 = sc.next();
String s2 = sc.nextLine();

in.next() 从缓冲区接收字符遇到空格后停止。 in.nextLine() 从缓冲区接收字符，并且接收空格，遇到换行才停止，并且会自动舍弃换行。

输出​

常用的几种方式： 

  • System.out.print(); //仅输出变量
  • System.out.println(); //输出变量后会自动换行
  • System.out.printf(); //格式化输出
    例：
    System.out.printf("%9.2f", d); //"9.2"中的9表示输出的长度，2表示小数点后的位数
    System.out.printf("%o", i); //"o"表示输出八进制整数
    System.out.printf("%x", i); //"x"表示输出十六进制整数
    System.out.printf("%s", i); //"d"表示输出字符串
    System.out.printf("%08", i);//输出位数为8的整数，不足前面补0(适合二进制格式)

数组​

定义​

int arr[] = new int[6];

初始化​

int arr = {1,2,3};

数组常用类--Arrays工具类​

Arrays类位于util包中 该工具类主要针对的是数组的操作 例：

import java.util.Arrays; //需要将Arrays导入

int a[] = {3,1,6,2,5};

int num1 = Arrays.binarySearch(a, 6); //获取指定值的下标(二分查找)
System.out.println(num1); //2

Arrays.sort(a); //按升序进行排序
String s1 = Arrays.toString(a); //返回数组字符串形式
System.out.println(s1); //[1, 2, 3, 5, 6]

String​

  • 字符串一旦创建就不可再改变(可重新指向)
  • 为了提升字符串的访问效率，程序中使用了“缓存”技术 因此在java中所有使用“双引号”括起来的字符串都会在“字符串常量池”中创建，字符串常量池在方法区中被储存(两个相同字符串在字符串常量池中保存的是相同地址)

String常用方法​

String类位于lang包中，无需导入 以下String指的是需要操作的String类型变量

String.chatAt(int);       //返回一个指定位置的char值
String.endsWith(String);  //判断一个字符串是否以endstr(字符串)结尾
String.equals(Object);    //判断对象(字符串)之间是否相等
String.equalsIgnoreCase(String); //判断字符串之间是否相等，不考虑大小写
String.indexOf(String str);      //返回指定字符串str在此字符串中第一次出现的索引，返回int值
String.lastIndexOf(String str);  //返回指定字符串str在此字符串中最后一次出现的索引，返回int值
String.length();                          //返回字符串长度，返回int值
String.replaceAll(String s1,String s2);   //在String中将所有的s1字符串替换为s2字符串，返回String值
String.replaceFirst(String s1,String s2); //只替换第一个子字符串，返回String值
String.split(String str);  //根据str字符串拆分String，返回String[]数组
String.toUpperCase();      //将String转换为大写，返回String值
String.toLowerCase();      //将String转换为小写，返回String值
String.toCharArray();      //将String转换为char数组，返回char[]数组
String.trim();             //去除String前后空白，返回String值

使用toCharArray()+增强for遍历String字符串​

String s1 = "12345";
char[] s2 = s1.toCharArray();
for(char a:s2){
System.out.print(a); //12345
}

竞赛常用类​

大数类​

概念​

  • 大数类位于java.math.*包中，其理论上可以储存无限位的大数
  • 大数类分为整数(BigInteger)和浮点数(BigDecimal)
  • 整数和浮点数不能混合运算

BigInteger和BigDecimal的使用​

创建​
  1. 直接声明
BigInteger num1;
BigDecimal num2;
  1. 构造函数初始化
BigInteger num1 = new BigInteger("12654655874");
BigDecimal num2 = new BigDecimal("1275646.5132545");
赋值--valueOf()​

valueOf()不能超过long类型的最大取值

num1 = BigInteger.valueOf(154847312562L); //若大于int的范围要加L
num2 = BigDecimal.valueOf(115643.135423);
加/减/乘/除--add()/subtract()/multiply()/divide()​
BigInteger num1 = new BigInteger("126546558741235123541212351235");
BigInteger num2 = new BigInteger("127564635415145145151235125111");
BigInteger num3;
num3 = num1.add(num2);       //加法运算
num3 = num1.subtract(num2);  //减法运算
num3 = num1.multiply(num2);  //乘法运算
num3 = num1.divide(num2);    //除法运算
num3 = num1.mod(num2);       //取余
num3 = num1.max(num2);       //求最大值
num3 = num1.min(num2);       //求最小值
num3 = num1.compareTo(num2); //比较大小
num3 = num1.gcd(BigInteger); //求最大公约数
System.out.print(num3);      //可直接输出

进制转换--BigInteger、String.format()、Integer的使用​

*转*进制--BigInteger​

BigInteger num = new BigInteger(str,2);  //二进制转十进制，str为String类型
BigInteger num = new BigInteger(str,8);  //八进制转十进制
BigInteger num = new BigInteger(str,16); //十六进制转十进制
String num1 = num.toString(2);     //十进制转二进制
String num1 = num.toString(8);     //十进制转八进制
String num1 = num.toString(16);    //十进制转十六进制

使用String.format()格式化实现十进制转八/十六进制​

String num = String.format("%o", o);    //十进制转八进制
String num = String.format("%x", o);    //十进制转十六进制

使用Integer类实现十进制转*进制​

Integer类位于java.lang包中，无需导包

String num = Integer.toBinaryString(i); //十进制转二进制，i为int类型
String num = Integer.toOctalString(i);  //十进制转八进制
String num = Integer.toHexString(i);    //十进制转十六进制

Math运算类​

Math类位于java.lang包下，无需导包

int num = Math.abs(-13);    //求绝对值 13
int num = Math.pow(3,2);    //求平方   9
double num = Math.floor(3.23); //取整(小于该数的最大整数)  3.0
double num = Math.ceil(3.23);  //取整(大于该数的最小整数)  4.0
double num = Math.PI           //取出π的值
double num = Math.round(3.24); //四舍五入(保留一位小数)    3.0
double num = Math.round(3.62566*100)/100.0;   //保留两位小数 3.63
double num = Math.round(3.62566*1000)/1000.0; //保留三位小数 3.626
double num = Math.sqrt(100)    //求平方根  10

Random随机数类​

Random类位于java.util包下，需要导包

import java.util.Random;   //导入Random包

Random rnd = new Random(); //创建构造方法
int num = rnd.nextInt();   //随机生成一个int类型的数
int num = rnd.nextInt(10);      //随机生成0~10之间的数(不包括10)
int num = rnd.nextInt(900)+100; //随机生成100~1000之间的数(不包括1000)

Calender日期类​

set(int field, int value); //第一个参数是日期字段，诸如YEAR、MONTH 等将给定的日历字段设置为给定值。 set(int year, int month, int date); // 设置日历字段YEAR、MONTH 和 DAY_OF_MONTH的值 例:

Calendar date = Calendar.getInstance(); //创建实例
// 设置日期为2021年4月17日
date.set(date.YEAR, 2021);      
date.set(date.MONTH, 3);           // 月份从下标0开始
date.set(date.DAY_OF_MONTH, 17);
// 获取2021年4月17日是星期几
System.out.print(date.get(date.DAY_OF_WEEK)); //星期六为一星期最后一天   7
// 增减时间
date.add(date.YEAR, 1);          // 增加1年
date.add(date.MONTH, 2);         // 增加2年
date.add(date.DAY_OF_MONTH, -1); // 减去1天

ArrayList类​

ArrayList位于java.util包中

List存储元素的特点: 有序可重复(存取的顺序相同)

构造列表​

ArrayList arr = new ArrayList();    //构造一个初始容量为 10 的空列表
ArrayList arr = new ArrayList(int); //构造一个具有指定初始容量的空列表

常用方法摘要​

注意返回值，API中可查

arr.add(Object e);             //将指定的元素添加到此列表的尾部
arr.add(int index, Object e);  //将指定的元素插入此列表中的指定位置
arr.get(int index);            //返回此列表中指定位置上的元素
arr.size();                    //获取列表中元素的个数
arr.clear();                   //清空列表
arr.isEmpty();                 //判断列表是否为空,为空则为true
arr.indexOf(Object o);         //返回此列表中首次出现的指定元素的索引
arr.lastIndexOf(Object o);     //返回此列表中最后一次出现的指定元素的索引
arr.toArray();                 //将列表转换成数组
arr.contains(Object o);        //判断列表中是否包含某个元素，包含则返回true
arr.remove(int index);         //删除列表中指定位置的元素
arr.remove(Object o);          //删除列表中首次出现的指定元素

Collections工具类可以对List集合中的元素排序

sort(arr);   //排序

ArrayList遍历的3种方式​

ArrayList arr = new ArrayList();
arr.add(1);
arr.add(2);
  1. for循环遍历
for(int i = 0;i<arr.size();i++){
    System.out.print(arr.get(i));
}
  1. 增强for遍历
for(Integer num:arr){
    System.out.print(num);
}
  1. Iterator迭代器遍历
for(Iterator it = arr.iterator();it.hasNext();){
    System.out.print(it.next());
}

迭代器解释:

arr.iterator();     //获取列表所依赖的迭代器对象
it.hasNext();       //判断是否下一位有元素，有则返回true
it.next();          //将迭代器向下移动一位，并且取出指向的元素
it.remove();        //移除迭代器返回的最后一个元素

SortedSet类​

SortedSet类位于java.util包中

set存储元素的特点: 无需不可重复(存取的顺序不一定相同，元素不可重复) 存进去的元素可以按照元素的大小自动排序 使用方法和ArrayList一致，两者都是父类Collection下的

HashMap类​

HashMap类位于java.util包中

Map集合特点: Map集合以键值对的方式存储元素(key和value) 键(key)特点是无序不可重复的 Map和Collection没有关系

Map集合中常用的方法​

map.put(key,value);       //向集合中添加键值对
map.get(key);             //通过key获取value
map.size();               //获取集合中键值对的个数
map.containsKey(key);     //判断集合中是否包含此key
map.containsValue(value); //判断集合中是否包含此value
map.remove(key);          //通过key将键值对删除
map.isEmpty();            //判断集合是否为空
map.clear();              //清空集合
map.keySet();             //获取集合中所有的key,返回值为set集合
map.values();             //获取集合中所有的values,返回值为Collection集合

例:

创建Map集合​
Map map = new HashMap();
存储键值对​
map.put("A","JACK");
map.put("B","SUN");
map.put("C","COOK");

Map存储过程中如果key重复了,value将会被覆盖

遍历Map集合​
  1. 迭代器遍历
set keys = map.keyset();
Iterator it = keys.iterator();
while(it.hasNext()){
Object id = it.next();      //得到key
Object name = map.get(id);  //得到value
System.out.print(name);
}
  1. 增强for遍历
for(String value:map.values()){
    System.out.print(value);  //遍历value
}
for(String key:map.keySet()){
    System.out.print(key);    //遍历key
}