当前位置:   article > 正文

蓝桥杯Java必备基础知识总结大全【3W字】持续更新中_蓝桥杯程序员纪元法java

蓝桥杯程序员纪元法java

本文会持续更新,如果对您有帮助的话可以点点关注,双击
在这里插入图片描述
本人2021年蓝桥杯C++B组国二,今年转战Java,并整理此文,希望能够对大家有所帮助,第一次写这么长的文章,可能有的地方写的不是很好,还请大家多多谅解,我会持续进行改进并且更新。
更新:2022年蓝桥杯JavaB组国二

在这里插入图片描述

第七届蓝桥杯国赛题解
第八届蓝桥杯国赛题解
第九届蓝桥杯国赛题解
第十届蓝桥杯国赛题解
第十一届蓝桥杯国赛题解
在这里插入图片描述注:内容为蓝桥杯来自蓝桥杯决赛特训营

蓝桥杯Jvav基础知识总结

输入和输出

输入
Scanner s = new Scanner(System.in);  //声明一个从控制台中读入数据的对象
int x = s.nextInt();
double x = s.nextDouble()String x = s.next();  //无法读入空格
String x = s.nextLine();  //可以读入空格,遇到换行停止
while(s.hasNext()) {  //hasNext() 判断还有没有读入值 相当于while(scanf())
    //如果有字符,返回true,否则阻塞
    //hasNext()不会返回false
}
s.hasNextInt();  //判断输入是否为int,是则返回,否则阻塞
s.hasNextDouble();  //判断输入是否为double,是则返回,否则阻塞
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
输出
System.out.println();
System.out.print();  
System.out.printf();  //格式化输出
  • 1
  • 2
  • 3

prinf()函数与C++中的prinf相同

print()和println()的区别是println()换行

封装输入和输出

通过重写函数的形式来缩写输入和输出,具体情况如下所示

输入
static int gtInt() {
    int x = sc.nextInt();
    return x;
}
  • 1
  • 2
  • 3
  • 4
输出
static void print(int x) {
    System.out.print(x);
}


static void println(int x) {
    System.out.println(x);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
快速读写

构造:

BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter w = new BufferedWriter(new OutputStreamWriter(System.out));
  • 1
  • 2
int x = r.read();  //读取一个字符并将其转换为UTF-8的值
eg: 输入123213123,x只能读取到1
String x = r.readLine();  //读取一行的值
String[] x = r.readLine().split(' ');  //分割字符形成字符串
  • 1
  • 2
  • 3
  • 4

需要注意的是 在windows中按一下回车键 一共有两个字符 “\n\r” 而read()只能读取一个字符所以如要要用read来达到吸收回车的目的,需要用两个read(); 如果用readLine()的话会将"\n\r"全部吸收 , 所以只需要一个readLine()来吸收回车

w.write(x);
w.write("\n");
w.flush();
w.write(Integer.toString(x));  //输出int型变量
  • 1
  • 2
  • 3
  • 4

需要注意的是 write() 不能直接输出int类型, 因为write(int a) 会输出其对应的ASCii码的字符

eg:write(65); => A

由于java是面向对象的语言,所以这里将快读和快写封装成类比较好用一些

快读类

StreamTokenizer读取字符类型,而BufferedReader读取字符串这里买呢StreamTokenizer也可以读取字符串,但是不会读取特殊符号和数字,所以我们最好用BufferedReader读取

static class FastRead {
    StreamTokenizer streamTokenizer;  //读取数字
    BufferedReader bufferedReader;  //读取字符串

    public FastRead() {
        streamTokenizer = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    int gtInt() throws IOException {
        streamTokenizer.nextToken();
        int x = (int) streamTokenizer.nval;
        return x;
    }

    long gtLong() throws IOException {
        streamTokenizer.nextToken();
        long l = (long) streamTokenizer.nval;
        return l;
    }

    double gtDouble() throws IOException {
        streamTokenizer.nextToken();
        double x = streamTokenizer.nval;
        return x;
    }

    String gtString() throws IOException {
        String s = bufferedReader.readLine();
        return s;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
快写类

快速输出这里我们选用的是printWriter

static class FastWrite {

   PrintWriter printWriter;

    public FastWrite() {
        printWriter = new PrintWriter(new OutputStreamWriter(System.out));
    }

    void print(int x) {
        printWriter.print(x);
    }

    void print(String sc) {
        printWriter.print(sc);
    }

    void print(double x) {
        printWriter.print(x);
    }

    void println(int x) {
        printWriter.println(x);
    }
    
    void println(double x) {
        printWriter.println(x);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

计算运行时间

Java的运算速度比C++慢,所以我们可以计算一下运行时间来判断是否会超时

long startTime = System.currentTimeMillis();    //获取开始时间
yourcode();  //你的代码
long endTime = System.currentTimeMillis();    //获取结束时间
System.out.println("程序运行时间:" + (endTime - startTime) + "ms");    //输出程序运行时间
  • 1
  • 2
  • 3
  • 4

数组

数组定义
int arr[] = new int[100];
int arr[][] = new int[100][100];
int arr[] = {1,2,3,4,5};
  • 1
  • 2
  • 3
数组常用函数
Arrays.fill(arr,0);  //全部赋值为0
Arrays.fill(arr,1,10,0);  //从第一个到第十个赋值为0
binarySearch(arr,5);  //二分搜索法查找5
binarySearch(arr,1,10,5);  //二分搜索法从第一个到第十个查找
newArr = copyOf(arr,10);  //复制数组,从0到10
newArr = copyOfRange(arr,1,10);  //复制数组,从1到10
sort(arr);  //排序
sort(arr,1,10);  //从1到10排序
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
浅拷贝与深拷贝
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
ArrayList<Integer> list1 = list;
ArrayList<Integer> list2 = (ArrayList<Integer>) list.clone();
list.set(0,2);
System.out.println(list1.get(0));  //答案为2
System.out.println(list2.get(0));  //答案为1
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

String StringBuilder StringBuffer

String类位于java.lang包下

String类

String类作为不可修改的对象,如果用String修改字符串会新建一个String对象,如果频繁修改,则会产生很多String对象,会产生很大的开销,效率也不是很高

提供了字符串的比较,查找,截取,大小写转换等操作

String类被final所修饰,不能被继承

//构造方法
String()构造空串

String(String)构造为String的串

String(Byte[],offset,length)  //用byte子数组构造String

String(char[])  //构造一个内容为char[]的字符串

String(char[],offset,count)  //取char[]的子数组
//常用方法

String.length()  //求长度

String.substring(begin)  //从begin处截取字串

String.substring(begin,end)  //从[begin,end)处截取字串

String.startwith(String)  //是否以该字串开始

String.endwith(String)  //是否以该字串结束

String.toString()  //返回该字符串本身

String.equals(String)  //比较相等

String.equalsIgnoreCase(String)  //比较是否相等,忽略大小写
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
StringBuffer类和StringBulider类(字符串缓冲区)

StringBuffer类(StringBuilder类同理,下同)作为可以修改的对象,如果是构造一个需要改变的String的话建议先使用StringBuffer,当String类不需要改变的时候再将其转换到String类

StringBuffer底层维护了一个字符数组,存储字符时实际上时往该字符数组中存储,初始化容量为16,当容量不够用时,自动增长一倍

StringBuffer类也具有String类的方法

//构造方法
string=stringBuffer.toString();  //将stringBuffer类转换为String类

stringBuffer()  //空stringBuffer串

stringBuffer(String)  //一个内容为String的stringBuffer类
//常用方法

stringBuffer.append(String)  //增加到字符串末尾

stringBuffer.append(char)
    
stringBuffer.length()  //返回长度
    
stringBuffer.replace(start, end, str) //从Start到end区间被str替代 
    
stringBuffer.reverse()  //反转形式取代

stringBuffer.insert(i,String)  //在i后插入String串

stringBuffer.delete(start,end)  //删除[start,end)处的字串

stringBuffer.indexOf(String)  //返回字串的第一次索引

stringBuffer.indexOf(String,fromIndex)  //返回从fromIndex处开始的第一次索引

stringBuffer.charAt(index)  //返回这个索引下的序列值
    
stringBuffer.setCharAt(index, char)  //将下标为index的值修改为char
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
StringBuffer与StringBuilder的区别

StringBuffer类所提供的方法都是同步的方法,属于安全的线程操作

StringBuilder类中的大多方法都是异步方法,属于线程安全的操作

如果多线程环境下涉及到大量修改的操作的话,则首先选择StringBuffer

如果非多线程环境下涉及到大量修改的操作的话,则首先选择StringBuilder

总的来说,执行速度的比较 StringBuilder>StringBuffer>String

Java数据结构

Java一共有 种数据结构时我们常用的,分别是以下几种

集合类型描述
ArrayList可以动态增长和缩减的序列,类似于C++的vector
LinkedList可以在任何位置高效插入和删除的有序序列,链表
ArrayDeque实现为循环数组的一个双端队列
HashSet没有重复元素的无序集合
TreeSet没有重复元素的有序集合
LinkedHashSet记住元素插入次序的集合
PriorityQueue优先队列
HashMap<K,V>型无序集合
TreeMap<K,V>型有序集合
LinkedHashMap记住添加次序的<K,V>型集合

以上所有数据结构都有以下这几种方法,需要记牢

boolean add(E e) 
//确保此集合包含指定的元素(可选操作)  
boolean addAll(Collection<? extends E> c) 
//将指定集合中的所有元素添加到此集合(可选操作)  
void clear() 
//从此集合中删除所有元素(可选操作)  
boolean contains(Object o) 
//如果此集合包含指定的元素,则返回 true   
boolean containsAll(Collection<?> c) 
//如果此集合包含指定 集合中的所有元素,则返回true  
boolean equals(Object o) 
//将指定的对象与此集合进行比较以获得相等性  
int hashCode() 
//返回此集合的哈希码值  
boolean isEmpty() 
//如果此集合不包含元素,则返回 true   
Iterator<E> iterator() 
//返回此集合中的元素的迭代器  
default Stream<E> parallelStream() 
//返回可能并行的 Stream与此集合作为其来源  
boolean remove(Object o) 
//从该集合中删除指定元素的单个实例(如果存在)(可选操作)  
boolean removeAll(Collection<?> c) 
//删除指定集合中包含的所有此集合的元素(可选操作)  
default boolean removeIf(Predicate<? super E> filter) 
//删除满足给定谓词的此集合的所有元素  
boolean retainAll(Collection<?> c) 
//仅保留此集合中包含在指定集合中的元素(可选操作)  
int size() 
//返回此集合中的元素数  
default Spliterator<E> spliterator() 
//创建一个Spliterator在这个集合中的元素  
default Stream<E> stream() 
//返回以此集合作为源的顺序 Stream   
Object[] toArray() 
//返回一个包含此集合中所有元素的数组  
<T> T[] toArray(T[] a) 
//返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
ArrayList
ArrayList<Integer> list = new ArrayList<>();  //创建一个ArrayList
list.add(1);  //向ArrayList中添加元素
list.addAll(list1);  //向ArrayList中插入新的ArrayList

try {
	list.add(1,2);  //将2插入到第一个元素中,第一个元素到最后一个元素依次往后移
    list.addAll(1,list1)  //将list1中所有元素插入到list的第一个里面
} catch (IndexOutOfBoundsException e) {
	//如果第一个数字 > list.size() 则会抛出异常
}
list.get(0);  //向ArrayList中获取第0个元素
list.set(0,2);  //将第0个元素设置为2
list.clear();  //清空list
boolean b = list.contains(1);  //判断list中是否含有1
boolean b = list.isEmpty();  //判断list是否为空
int i = list.indexOf(1);  //查询list中第一次出现1的位置下标,没有则返回-1
int i = list.lastIndexOf(1);  //查询list中最后出现1的位置下标,没有则返回-1

int x = list.remove(0);  //删除第0号元素,同时将第0号元素的值返回
boolean b = list.remove(new Integer(3));  //删除list中第一个出现3的元素
/*
 * 当list为Integer类型是,list.remove(0)会被认为删除第0号元素而不是删除第一个出现0的元素
*/
System.out.prinltn(list.size());  //输出list的size大小
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
LinkedList

LinkedList的操作和ArrayList差不多,这里记录一些ArrayList中没有的一些API

void addFirst(E e) 
在该列表开头插入指定的元素  
void addLast(E e) 
将指定的元素追加到此列表的末尾 
boolean contains(Object o) 
如果此列表包含指定的元素,则返回 true   
Iterator<E> descendingIterator() 
以相反的顺序返回此deque中的元素的迭代器  
E getFirst() 
返回此列表中的第一个元素  
E getLast() 
返回此列表中的最后一个元素  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
LinkedList和ArrayList的区别

LinkedList就是链表,ArrayList就是数组

LinkedList插入和删除中间的元素十分方便,但是随机访问的能力很弱

ArrayList插入和删除中间的元素开销大,但是随机访问的能力很强

Stack
Stack<Integer> stack = new Stack<>();  //创建一个新stack
stack.push(1);  //将1压入到stack中
int x = stack.peek();  //获取栈顶元素并且不使栈顶元素出栈
int x = stack.pop();  //获取栈顶元素并且使得栈顶元素出栈
int x = stack.search(1);  //查找离栈顶元素最近的1离栈顶的位置
eg: 1 2 3 4 5 1 2 3 4 5
stack.search(1);  //返回值为3
stack.search(5);  //返回值为5
eg: 1 2 3 4 5
stack.search(5);  //返回值为-1
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
boolean empty() 
//测试此堆栈是否为空  
E peek() 
//查看此堆栈顶部的对象,而不从堆栈中删除它  
E pop() 
//删除此堆栈顶部的对象,并将该对象作为此函数的值返回  
E push(E item) 
//将项目推送到此堆栈的顶部  
int search(Object o) 
//返回一个对象在此堆栈上的基于1的位置  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

Set

set可以先不声明自己的泛型,这样的set可以插入不同的类,如下所示

HashSet s = new HashSet();
s.add("Polaris111");
s.add(123456);
s.add(new BigDecimal(123.456));
System.out.println(s);
  • 1
  • 2
  • 3
  • 4
  • 5

打印出来的结果如下所示

在这里插入图片描述

Java的set一共分为两类,不能排序HashSet和能够排序的TreeSet,接下来让我分别介绍这两个类

HashSet
基本操作
HashSet<String> s = new HashSet<>();
s.add("str1");  //添加
s.add("str2");
s.add("str3");
System.out.println(s.isEmpty());  //判空
System.out.println(s.contains("str1"));  //判断集合是否包含元素
System.out.println(s.size());  //集合中元素个数
System.out.println(s.remove("str1"));  //删除元素
s.clear();  //清空所有元素
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

输出结果如下所示

在这里插入图片描述

遍历
//第一种
Iterator it = s.iterator();
while(it.hasNext()) {
    if(it.next().equals("str2")) {
		it.remove();
    }
}
//第二种
for(String str : s) {
    System.out.println(s);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
TreeSet

TreeSet的内部实现是红黑树,基本操作方式和HashSet相同基本相同

TreeSet<String> s = new TreeSet<>();
s.add("str1");  //添加
s.add("str2");
s.add("str3");
System.out.println(s.isEmpty());  //判空
System.out.println(s.contains("str1"));  //判断集合是否包含元素
System.out.println(s.size());  //集合中元素个数
System.out.println(s.remove("str1"));  //删除元素
s.clear();  //清空所有元素
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

输出结果如下所示

在这里插入图片描述

遍历
//第一种
Iterator it = s.iterator();
while(it.hasNext()) {
    if(it.next().equals("str2")) {
		it.remove();
    }
}
//第二种
for(String str : s) {
    System.out.println(s);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
HashMap
HashMap<Integer, String> hashMap = new HashMap<>();  //创建元素
hashMap.put(1, "test1");  //插入元素
hashMap.put(2, "test2");
hashMap.put(3, "test3");
System.out.println(hashMap.get(1));  //取元素
System.out.println(hashMap.isEmpty());  //判空
System.out.println(hashMap.size());  //输出元素数量
//判断键是否存在
if(hashMap.containsKey(1)) {
	System.out.println("1存在");
}
//判断值是否存在
if(hashMap.containsValue("test1")) {
	System.out.println("test1存在");
}
hashMap.remove(1);  //删除Key为1的元素
hashMap.remove(2,"test2");  //删除Key为2且值为test2的元素
hashMap.replace(3, "test4");  //将Key为3的元素的Value替换为"test4"
hashMap.replace(3, "test4", "test5");  //将Key为3且Value为"test4"的值替换为"test5"
Set<Map.Entry<Integer, String>> set = hashMap.entrySet();  //获取键
Iterator iterator = set.iterator();
while(iterator.hasNext()) {
	Map.Entry<Integer, String> it = (Entry<Integer, String>) iterator.next();
	System.out.println(it.getKey());  //取键
	System.out.println(it.getValue());  //取值
	System.out.println(it.setValue("null"));  //重新设置值
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
TreeMap

TreeMap的操作与HashMap差不多,这里我写几个TreeMap特有的操作

TreeMap<Integer, String> treeMap = new TreeMap<>();  //创建元素
treeMap.put(1, "test1");  //插入元素
treeMap.put(2, "test2");
treeMap.put(3, "test3");
Integer integer = treeMap.ceilingKey(3);  //  返回大于或等于给定键的键,如果没有此键,则返回null
System.out.println(integer);
Map.Entry<Integer, String> entry = treeMap.ceilingEntry(3);  //  返回与大于或等于给定键的最小键相关联的键值映射,如果没有此键,则返回null
System.out.println(entry.getKey());  //取键
System.out.println(entry.getValue());  //取值
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

TreeMap在寻找值除了上述的操作外还有以下的操作:

Map.Entry<K,V> ceilingEntry(K key) 
//返回与大于或等于给定键的最小键相关联的键值映射,如果没有此键,则 null
K ceilingKey(K key) 
//返回大于或等于给定键的 null键,如果没有此键,则返回 null  
Map.Entry<K,V> firstEntry() 
//返回与该地图中的最小键相关联的键值映射,如果地图为空,则返回 null   
K firstKey() 
//返回此地图中当前的第一个(最低)键  
Map.Entry<K,V> floorEntry(K key) 
//返回与小于或等于给定键的最大键相关联的键值映射,如果没有此键,则 null   
K floorKey(K key) 
//返回小于或等于给定键的最大键,如果没有这样的键,则返回 null   
SortedMap<K,V> headMap(K toKey) 
//返回此地图部分的视图,其密钥严格小于 toKey   
NavigableMap<K,V> headMap(K toKey, boolean inclusive) 
//返回此地图部分的视图,其键值小于(或等于,如果 inclusive为真) toKey   
Map.Entry<K,V> higherEntry(K key) 
//返回与最小密钥相关联的密钥值映射严格大于给定密钥,如果没有这样的密钥则 null   
K higherKey(K key) 
//返回严格大于给定键的最小键,如果没有这样的键,则返回 null   
Map.Entry<K,V> lastEntry() 
//返回与该地图中最大关键字关联的键值映射,如果地图为空,则返回 null   
K lastKey() 
//返回当前在此地图中的最后(最高)键  
Map.Entry<K,V> lowerEntry(K key) 
//返回与最大密钥相关联的密钥值映射严格小于给定密钥,如果没有这样的密钥,则 null   
K lowerKey(K key) 
//返回严格小于给定键的最大键,如果没有这样的键,则返回 null   
Map.Entry<K,V> pollFirstEntry() 
//删除并返回与该地图中的最小键相关联的键值映射,如果地图为空,则返回 null   
Map.Entry<K,V> pollLastEntry() 
//删除并返回与该地图中最大密钥相关联的键值映射,如果地图为空,则返回 null   
NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) 
//返回此地图部分的视图,其关键范围为 fromKey至 toKey   
SortedMap<K,V> subMap(K fromKey, K toKey) 
//返回此地图部分的视图,其关键字范围从 fromKey (含)到 toKey ,独占  
SortedMap<K,V> tailMap(K fromKey) 
//返回此地图部分的视图,其键大于等于 fromKey   
NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) 
//返回此地图部分的视图,其键大于(或等于,如果 inclusive为真) fromKey   

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
PriorityQueue

PriorityQueue默认小根堆,要想生成大根堆,可以按照如下方式生成。

PriorityQueue<Integer> priorityQueue = new PriorityQueue<>((x,y) -> (y-x));
  • 1
基本操作
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
priorityQueue.offer(1);  //插入元素
priorityQueue.offer(2);
priorityQueue.offer(3);
priorityQueue.offer(4);
priorityQueue.offer(5);
System.out.println(priorityQueue.poll());  //查找队头并删除队头
System.out.println(priorityQueue.peek());  //查找队头
System.out.println(priorityQueue.size());  //输出元素数量
priorityQueue.remove(4);  //删除元素如果存在
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

自定义排序

HashSet可以自定义排序函数,也可以让HashSet排序的类里面重载compareTo函数,操作如下所示

public int compare(String o1, String o2):比较其两个参数的顺序

    static class MyClass {
        public int f;
        public int s;
    }

    static class MyComparator implements Comparator<MyClass> {
        @Override
        public int compare(MyClass o1, MyClass o2) {
            if(o1.f != o2.f) {
                if(o1.f > o2.f) {
                    return 1;
                } else {
                    return -1;
                }
            } else {
                if(o1.s > o2.s) {
                    return 1;
                } else {
                    return -1;
                }
            }
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

两个对象比较的结果有三种:大于,等于,小于

如果要按照升序排序,
则o1 小于o2,返回(负数),相等返回0,01大于02返回(正数)
如果要按照降序排序
则o1 小于o2,返回(正数),相等返回0,01大于02返回(负数)

做如下测试,可以看到TreeSet按照我们给提供的接口去进行排序的

TreeSet<MyClass> treeSet = new TreeSet<>(new MyComparator());
        treeSet.add(new MyClass(1, 2));
        treeSet.add(new MyClass(2, 2));
        treeSet.add(new MyClass(2, 3));
        treeSet.add(new MyClass(4, 3));
        treeSet.add(new MyClass(5, 6));
        treeSet.add(new MyClass(7, 3));
        Iterator it = treeSet.iterator();
        while(it.hasNext()) {
            System.out.println(it.next().toString());
        }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

在这里插入图片描述

也可以在声明类的时候继承Comparable接口来自定义排序方法,这样TreeSet这种排序集合在排序的时候就会执行我们自定义类中的方法

static class MyClass implements Comparable<MyClass> {
        public int f;
        public int s;

        @Override
        public int compareTo(MyClass o) {
            if(this.f != o.f) {
                if(this.f > o.f) {
                    return 1;
                } else {
                    return -1;
                }
            } else {
                if(this.s > o.s) {
                    return 1;
                } else {
                    return -1;
                }
            }
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

同样是进行和上面一样的测试,可以发现结果是一样的,TreeSet这种排序集合在排序的时候就会执行类中的compareTo方法

TreeSet<MyClass> treeSet = new TreeSet<>();
        treeSet.add(new MyClass(1, 2));
        treeSet.add(new MyClass(2, 2));
        treeSet.add(new MyClass(2, 3));
        treeSet.add(new MyClass(4, 3));
        treeSet.add(new MyClass(5, 6));
        treeSet.add(new MyClass(7, 3));
        Iterator it = treeSet.iterator();
        while(it.hasNext()) {
            System.out.println(it.next().toString());
        }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

结果如下所示

]

如果二者都不定义直接排序呢?答案是不可以的,编译器会报如下的错误:

在这里插入图片描述

Java API

大数类

大数类一共有两个,分别是BigInteger和BigDecimal,大数整形变量以及大数浮点数,理论上可以存储无线长的数字(只要你计算机的内存足够),接下来我将会分别介绍这两个类。

BigInteger
构造函数

BigInteger一共有六个构造方法,分别是以下六个,个人认为最常用的应该是第五个将字符串转换为BigInteger。

BigInteger b = BigInteger(byte[] val) 
//将包含BigInteger的二进制补码二进制表达式的字节数组转换为BigInteger。  
BigInteger b = BigInteger(int signum, byte[] magnitude) 
//将BigInteger的符号大小表示形式转换为BigInteger。  
BigInteger b = BigInteger(int bitLength, int certainty, Random rnd) 
//构造一个随机生成的正BigInteger,它可能是素数,具有指定的bitLength。  
BigInteger b = BigInteger(int numBits, Random rnd) 
//构造一个随机生成的BigInteger,均匀分布在0到(2 numBits - 1)的范围内。  
BigInteger b = BigInteger(String val) 
//将BigInteger的十进制字符串表示形式转换为BigInteger。  
BigInteger b = BigInteger(String val, int radix) 
//将指定基数中的BigInteger的String表示形式转换为BigInteger。  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
输入

BigInteger类是可以直接读入的,当然你也可以选择先读入字符串然后再转到BigInteger。

Scanner s = new Scanner(System.in);
while (sc.hasNextBigInteger()) {
BigInteger b = s.nextBigInteger();  //读取BigInteger
  • 1
  • 2
  • 3
输出

BigInteger类是可以直接输出的

System.out.println(b);
  • 1
四则运算

BigInteger的四则运算不能用基础的四个符号进行操作,而是需要用BigInteger的方法来实现。

BigInteger b1 = new BigInteger("1000000");
BigInteger b2 = new BigInteger("-2000000");
System.out.println(b2.add(b1));  //加
System.out.println(b2.subtract(b1));  //减
System.out.println(b2.multiply(b1));   //乘
System.out.println(b2.divide(b1));   //除
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
其他运算
System.out.println(b2.remainder(b1));   //取余
System.out.println(b2.negate());   //取负号
System.out.println(b2.equals(b1));   //判断相等
System.out.println(b2.gcd(b1));   //求最大公约数
System.out.println(b2.max(b1));   //求最大值
System.out.println(b2.min(b1));   //求最小值
System.out.println(b2.pow(100000));   //开方
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
位运算
System.out.println(b2.and(b1));   //并
System.out.println(b2.not());    //取反
System.out.println(b2.or(b1));   //或
System.out.println(b2.xor(b1));   //异或
  • 1
  • 2
  • 3
  • 4
方法

BigInteger 的方法如下所示(注意不是静态方法)

BigInteger abs() 
//返回一个BigInteger,它的值是此BigInteger的绝对值。  
BigInteger add(BigInteger val) 
//返回值为 (this + val) 。  
BigInteger and(BigInteger val) 
//返回值为 (this & val) 。  
BigInteger andNot(BigInteger val) 
//返回值为 (this & ~val) 。  
int bitCount() 
//返回与其符号位不同的BigInteger的二进制补码表示中的位数。  
int bitLength() 
//返回此BigInteger的最小二进制补码表示中的位数, 不包括符号位。  
byte byteValueExact() 
//将此 BigInteger转换为 byte ,检查丢失的信息。  
BigInteger clearBit(int n) 
//返回一个BigInteger,其值等于此BigInteger,指定的位被清零。  
int compareTo(BigInteger val) 
//将此BigInteger与指定的BigInteger进行比较。  
BigInteger divide(BigInteger val) 
//返回值为 (this / val) 。  
BigInteger[] divideAndRemainder(BigInteger val) 
//返回两个BigInteger的数组,其中包含 (this / val)后跟 (this % val) 。  
double doubleValue() 
//将此BigInteger转换为 double 。  
boolean equals(Object x) 
//将此BigInteger与指定的对象进行比较以实现相等。  
BigInteger flipBit(int n) 
//返回一个BigInteger,其值等于此BigInteger,指定的位被翻转。  
float floatValue() 
//将此BigInteger转换为 float 。  
BigInteger gcd(BigInteger val) 
//返回一个BigInteger,其值是 abs(this)和 abs(val) 。  
int getLowestSetBit() 
//返回此BigInteger中最右(最低位)一位的索引(最右边一位右侧的零位数)。  
int hashCode() 
//返回此BigInteger的哈希码。  
int intValue() 
//将此BigInteger转换为 int 。  
int intValueExact() 
//将此 BigInteger转换为 int ,检查丢失的信息。  
boolean isProbablePrime(int certainty) 
//返回 true如果这个BigInteger可能是素数, false如果它是绝对复合。  
long longValue() 
//将此BigInteger转换为 long 。  
long longValueExact() 
//将此 BigInteger转换为 long ,检查丢失的信息。  
BigInteger max(BigInteger val) 
//返回此BigInteger和 val 。  
BigInteger min(BigInteger val) 
//返回此BigInteger和 val 。  
BigInteger mod(BigInteger m) 
//返回值为 (this mod m )。  
BigInteger modInverse(BigInteger m) 
//返回值为 (this -1 mod m) 。  
BigInteger modPow(BigInteger exponent, BigInteger m) 
//返回值为 (thisexponent mod m)的BigInteger 。  
BigInteger multiply(BigInteger val) 
//返回值为 (this * val) 。  
BigInteger negate() 
//返回值为 (-this) 。  
BigInteger nextProbablePrime() 
//返回大于这个 BigInteger为 BigInteger的第一个整数。  
BigInteger not() 
//返回值为 (~this) 。  
BigInteger or(BigInteger val) 
//返回值为 (this | val) 。  
BigInteger pow(int exponent) 
//返回值为 (thisexponent)的BigInteger 。  
static BigInteger probablePrime(int bitLength, Random rnd) 
//返回一个正的BigInteger,它可能是素数,具有指定的位长度。  
BigInteger remainder(BigInteger val) 
//返回值为 (this % val) 。  
BigInteger setBit(int n) 
//返回一个BigInteger,其值等于具有指定位集合的BigInteger。  
BigInteger shiftLeft(int n) 
//返回值为 (this << n) 。  
BigInteger shiftRight(int n) 
//返回值为 (this >> n) 。  
short shortValueExact() 
//将此 BigInteger转换为 short ,检查丢失的信息。  
int signum() 
//返回此BigInteger的signum函数。  
BigInteger subtract(BigInteger val) 
//返回值为 (this - val) 。  
boolean testBit(int n) 
//返回 true当且仅当指定的位被设置。  
byte[] toByteArray() 
//返回一个包含此BigInteger的二进制补码表示的字节数组。  
String toString() 
//返回此BigInteger的十进制字符串表示形式。  
String toString(int radix) 
//返回给定基数中BigInteger的String表示形式。  
static BigInteger valueOf(long val) 
//返回一个BigInteger,其值等于指定的 long 。  
BigInteger xor(BigInteger val) 
//返回值为 (this ^ val) 。  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
BigDecimal
构造函数

BigDecimal一共有十六个构造方法,分别是以下十六个,同样最常用的方法我认为还是传入字符串

BigDecimal(BigInteger val) 
//将 BigInteger转换成 BigDecimal 。  
BigDecimal(BigInteger unscaledVal, int scale) 
//将BigInteger的 BigInteger值和 int等级转换为 BigDecimal 。  
BigDecimal(BigInteger unscaledVal, int scale, MathContext mc) 
//将 BigInteger未缩放值和 int扩展转换为 BigDecimal ,根据上下文设置进行舍入。  
BigDecimal(BigInteger val, MathContext mc) 
//根据上下文设置将 BigInteger转换为 BigDecimal舍入。  
BigDecimal(char[] in) 
//一个转换的字符数组表示 BigDecimal成 BigDecimal ,接受字符作为的相同序列 BigDecimal(String)构造。  
BigDecimal(char[] in, int offset, int len) 
//一个转换的字符数组表示 BigDecimal成 BigDecimal ,接受字符作为的相同序列 BigDecimal(String)构造,同时允许一个子阵列被指定。  
BigDecimal(char[] in, int offset, int len, MathContext mc) 
//一个转换的字符数组表示 BigDecimal成 BigDecimal ,接受字符作为的相同序列 BigDecimal(String)构造,同时允许指定一个子阵列和用根据上下文设置进行舍入。  
BigDecimal(char[] in, MathContext mc) 
//一个转换的字符数组表示 BigDecimal成 BigDecimal ,接受相同的字符序列作为 BigDecimal(String)构造与根据上下文设置进行舍入。 
BigDecimal(double val) 
//将 double转换为 BigDecimal ,这是 double的二进制浮点值的精确十进制表示。  
BigDecimal(double val, MathContext mc) 
//将 double转换为 BigDecimal ,根据上下文设置进行舍入。  
BigDecimal(int val) 
//将 int成 BigDecimal 。  
BigDecimal(int val, MathContext mc) 
//将 int转换为 BigDecimal ,根据上下文设置进行舍入。  
BigDecimal(long val) 
//将 long成 BigDecimal 。  
BigDecimal(long val, MathContext mc) 
//将 long转换为 BigDecimal ,根据上下文设置进行舍入。  
BigDecimal(String val) 
//将BigDecimal的字符串表示 BigDecimal转换为 BigDecimal 。  
BigDecimal(String val, MathContext mc) 
//一个转换的字符串表示 BigDecimal成 BigDecimal ,接受相同的字符串作为 BigDecimal(String)构造,利用根据上下文设置进行舍入。 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

注意:

上面的那些是我从JavaAPI上面得来的,但是以下这一点一定要注意!

最好使用String来传参构造,而不用double,原因如下

请看下列代码

BigDecimal b1 =new BigDecimal(0.1);
System.out.println(b1);
BigDecimal b2 =new BigDecimal("0.1");
System.out.println(b2);
  • 1
  • 2
  • 3
  • 4

最后的结果为:

在这里插入图片描述

为什么会这样呢?

double构造的结果具有一定的不可预知性,因为由于二进制的原因0.1并没有办法很好的表示,二传入String的构造结果是完全可信的,也就是会正好的得到想要的0.1,所以我们构造BigDecimal的值时最好使用String来构造。

输入

BigDecimal类是可以直接读入的,当然你也可以选择先读入字符串然后再转到BigDecimal。

Scanner s = new Scanner(System.in);
while (sc.hasNextBigDecimal()) {
	BigDecimal b = s.nextBigDecimal();  //读取BigInteger
}
  • 1
  • 2
  • 3
  • 4
输出

BigDecimalr类是可以直接输出的

System.out.println(b);
  • 1
四则运算

BigDecimal的四则运算不能用基础的四个符号进行操作,而是需要用BigDecimal的方法来实现。

BigDecimal b1 =new BigDecimal(0.1);
BigDecimal b2 =new BigDecimal("0.2");
System.out.println(b2.add(b1));  //加
System.out.println(b2.subtract(b1));  //减
System.out.println(b2.multiply(b1));   //乘
System.out.println(b2.divide(b1));   //除
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
其他运算
System.out.println(b2.remainder(b1));   //取余
System.out.println(b2.negate());   //取负号
System.out.println(b2.equals(b1));   //判断相等
System.out.println(b2.compareTo(b1));  //比大小(比得过是1,相等是0,比不过是-1)
System.out.println(b2.gcd(b1));   //求最大公约数
System.out.println(b2.max(b1));   //求最大值
System.out.println(b2.min(b1));   //求最小值
System.out.println(b2.pow(100000));   //开方
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
方法

BigDecimal的方法如下所示(注意不是静态方法)

BigDecimal abs() 
//返回一个 BigDecimal ,其值为此 BigDecimal的绝对值,其缩放比例为 this.scale() 。  
BigDecimal abs(MathContext mc) 
//返回一个 BigDecimal ,其值为此 BigDecimal的绝对值,根据上下文设置进行舍入。  
BigDecimal add(BigDecimal augend) 
//返回 BigDecimal ,其值是 (this + augend) ,其标为 max(this.scale(), augend.scale()) 。  
BigDecimal add(BigDecimal augend, MathContext mc) 
//返回 BigDecimal ,其值是 (this + augend) ,根据上下文设置进行舍入。  
byte byteValueExact() 
//将此 BigDecimal转换为 byte ,检查丢失的信息。  
int compareTo(BigDecimal val) 
//将此 BigDecimal与指定的BigDecimal进行 BigDecimal 。  
BigDecimal divide(BigDecimal divisor) 
//返回BigDecimal ,其值为(this / divisor) ,优先级为(this.scale() - divisor.scale()) ; 如果不能表示确切的商(因为它具有非终止的十进制扩展),则抛出一个ArithmeticException 。  
BigDecimal divide(BigDecimal divisor, int roundingMode) 
//返回 BigDecimal ,其值是 (this / divisor) ,其标为 this.scale() 。  
BigDecimal divide(BigDecimal divisor, int scale, int roundingMode) 
//返回一个 BigDecimal ,其值为 (this / divisor) ,其比例为指定。  
BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode) 
//返回一个 BigDecimal ,其值为 (this / divisor) ,其比例为指定。  
BigDecimal divide(BigDecimal divisor, MathContext mc) 
//返回 BigDecimal ,其值是 (this / divisor) ,根据上下文设置进行舍入。  
BigDecimal divide(BigDecimal divisor, RoundingMode roundingMode) 
//返回 BigDecimal ,其值是 (this / divisor) ,其标为 this.scale() 。  
BigDecimal[] divideAndRemainder(BigDecimal divisor) 
//返回一个两元件 BigDecimal阵列含有的结果 divideToIntegralValue接着的结果 remainder上的两个操作数。  
BigDecimal[] divideAndRemainder(BigDecimal divisor, MathContext mc) 
//返回一个两元件 BigDecimal阵列含有的结果 divideToIntegralValue接着的结果 remainder上与根据上下文设置进行舍入计算出的两个操作数。  
BigDecimal divideToIntegralValue(BigDecimal divisor) 
//返回一个 BigDecimal ,它的值是 BigDecimal的整数部分 (this / divisor)取整。  
BigDecimal divideToIntegralValue(BigDecimal divisor, MathContext mc) 
//返回值为 BigDecimal的整数部分的 (this / divisor) 。  
double doubleValue() 
//将此 BigDecimal转换为 double 。  
boolean equals(Object x) 
//将此 BigDecimal与指定的 Object进行比较以获得相等性。  
float floatValue() 
//将此 BigDecimal转换为 float 。  
int hashCode() 
//返回此 BigDecimal的哈希码。  
int intValue() 
//将此 BigDecimal转换为 int 。  
int intValueExact() 
//将此 BigDecimal转换为 int ,检查丢失的信息。  
long longValue() 
//将此 BigDecimal转换为 long 。  
long longValueExact() 
//将此 BigDecimal转换为 long ,检查丢失的信息。  
BigDecimal max(BigDecimal val) 
//返回此 BigDecimal和 val 。  
BigDecimal min(BigDecimal val) 
//返回此 BigDecimal和 val 。  
BigDecimal movePointLeft(int n) 
//返回一个 BigDecimal ,相当于这个小数点,向左移动了 n个地方。  
BigDecimal movePointRight(int n) 
//返回一个 BigDecimal ,相当于这个小数点移动了 n个地方。  
BigDecimal multiply(BigDecimal multiplicand) 
//返回 BigDecimal ,其值是 (this × multiplicand),其标为 (this.scale() + multiplicand.scale()) 。  
BigDecimal multiply(BigDecimal multiplicand, MathContext mc) 
//返回 BigDecimal ,其值是 (this × multiplicand),根据上下文设置进行舍入。  
BigDecimal negate() 
//返回 BigDecimal ,其值是 (-this) ,其标为 this.scale() 。  
BigDecimal negate(MathContext mc) 
//返回 BigDecimal ,其值是 (-this) ,根据上下文设置进行舍入。  
BigDecimal plus() 
//返回 BigDecimal ,其值是 (+this) ,其标为 this.scale() 。  
BigDecimal plus(MathContext mc) 
//返回 BigDecimal ,其值是 (+this) ,根据上下文设置进行舍入。  
BigDecimal pow(int n) 
//返回 BigDecimal ,其值是 (thisn),该电源,准确计算,使其具有无限精度。  
BigDecimal pow(int n, MathContext mc) 
//返回 BigDecimal ,其值是 (thisn)。  
int precision() 
//返回此 BigDecimal的 BigDecimal 。  
BigDecimal remainder(BigDecimal divisor) 
//返回 BigDecimal ,其值是 (this % divisor) 。  
BigDecimal remainder(BigDecimal divisor, MathContext mc) 
//返回 BigDecimal ,其值是 (this % divisor) ,根据上下文设置进行舍入。  
BigDecimal round(MathContext mc) 
//返回 BigDecimal根据四舍五入 MathContext设置。  
int scale() 
//返回此 规模 BigDecimal 。  
BigDecimal scaleByPowerOfTen(int n) 
//返回一个BigDecimal,其数值等于( this * 10 n )。  
BigDecimal setScale(int newScale) 
//返回一个 BigDecimal ,其大小是指定值,其值在数字上等于此 BigDecimal 。  
BigDecimal setScale(int newScale, int roundingMode) 
//返回一个 BigDecimal ,其规模是指定值,其缩放值通过将此 BigDecimal的非标度值乘以10的适当功率来确定,以维持其总体值。  
BigDecimal setScale(int newScale, RoundingMode roundingMode) 
//返回一个 BigDecimal ,其规模是指定值,其缩放值通过将该 BigDecimal的非标度值乘以10的适当功率来确定,以维持其整体值。  
short shortValueExact() 
//将此 BigDecimal转换为 short ,检查丢失的信息。  
int signum() 
//返回这个 BigDecimal的signum函数。  
BigDecimal stripTrailingZeros() 
//返回一个 BigDecimal ,它在数字上等于此值, BigDecimal表示中删除任何尾随的零。  
BigDecimal subtract(BigDecimal subtrahend) 
//返回 BigDecimal ,其值是 (this - subtrahend) ,其标为 max(this.scale(), subtrahend.scale()) 。  
BigDecimal subtract(BigDecimal subtrahend, MathContext mc) 
//返回 BigDecimal ,其值是 (this - subtrahend) ,根据上下文设置进行舍入。  
BigInteger toBigInteger() 
//将此 BigDecimal转换为 BigInteger 。  
BigInteger toBigIntegerExact() 
//将此 BigDecimal转换为 BigInteger ,检查丢失的信息。  
String toEngineeringString() 
//如果需要指数,则使用工程符号返回此 BigDecimal的字符串表示形式。  
String toPlainString() 
//返回没有指数字段的此 BigDecimal的字符串表示形式。  
String toString() 
//返回此 BigDecimal的字符串表示,如果需要指数,则使用科学计数法。  
BigDecimal ulp() 
//返回此 BigDecimal的最后一个位置的ulp(一个单位)的大小。  
BigInteger unscaledValue() 
//返回一个 BigInteger ,其值是此 BigDecimal的 未缩放值 。  
static BigDecimal valueOf(double val) 
//转换一个 double成 BigDecimal ,使用 double通过所提供的规范的字符串表示 Double.toString(double)方法。  
static BigDecimal valueOf(long val) 
//将 long值转换为 BigDecimal ,比例为零。  
static BigDecimal valueOf(long unscaledVal, int scale) 
//将 long值和 int比例转换为 BigDecimal 。  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120

时间类Calendar

Calendar类是一个抽象类,可以为在某一特定时刻和一组之间的转换的方法如YEARMONTHDAY_OF_MONTHHOUR ,等等,以及用于操纵该日历字段,如获取的日期下个星期。 时间上的瞬间可以用毫秒值表示,该值是从1970年1月1日00:00 00:00.000 GMT(Gregorian)的偏移量。

Calendar的基本使用方法如下所示:

Calendar c = Calendar.getInstance();  //生成一个新的Calendar类
c.set(2022, 3, 24, 10, 10, 10);  //set(int year, int month, int date, int hourOfDay, int minute, int second)
cal.set(Calendar.YEAR, 2022);  //set(int field, int value) 将给定的日历字段设置为给定的值
System.out.println(c.get(Calendar.YEAR));  //输出当前年
System.out.println(c.get(Calendar.MONTH));  //输出当前月
System.out.println(c.get(Calendar.DATE));  //输出当前日
System.out.println(c.get(Calendar.DAY_OF_WEEK));  //输出当前的星期
System.out.println(c.get(Calendar.HOUR_OF_DAY));  //输出当前小时
System.out.println(c.get(Calendar.MINUTE));  //输出当前分钟
System.out.println(c.get(Calendar.SECOND));  //输出当前秒数
System.out.println(c.getTimeInMillis());  //输出当前时间戳
System.out.println(c.getTime());  //输出的是一个Date对象,表示当前的日期
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

如果我们相对当前生成的Calendar类进行一个日期的加或减,那么我们可以有以下的两种操作方法

c.setTimeInMillis(1L);  //设置时间戳
c.add(Calendar.MINUTE, 1);  //add(int field, int amount) 根据日历的规则,将指定的时间量添加或减去给定的日历字段。
//add的值可以为负数
cal.set(Calendar.YEAR, 2022);  //set(int field, int value) 将给定的日历字段设置为给定的值
  • 1
  • 2
  • 3
  • 4

Calendar的set和get常用的字段有:

static int AM 
AM字段表示12小时制的当前小时
static int AM_PM 
AM_PM字段表示24小时制的当前小时
static int DATE 
DATE字段编号表示该月的日期。  
static int DAY_OF_MONTH 
get字段编号和 set本月的日期。
static int DAY_OF_WEEK 
get字段编号和 set表示一周中的日期。  
static int DAY_OF_WEEK_IN_MONTH 
get字段编号和 set当月的 set几的序号。
static int DAY_OF_YEAR 
get和 set字段编号, set本年度的日数。  
static int HOUR 
get和 set字段编号, get上午或下午的小时。  
static int HOUR_OF_DAY 
get字段编号和 set当天的小时数。     
static int MILLISECOND 
get和 set字段号表示 get内的 set数。  
static int MINUTE 
get和 set字段编号表示小时内的分钟。  
static int MONDAY 
DAY_OF_WEEK字段的值表示星期一。  
static int MONTH 
get和 set字段号表示月份。  
static int PM 
AM_PM字段的值表示从中午到午夜之前的一天中的一段时间。  
static int SATURDAY 
DAY_OF_WEEK字段的值表示星期六。  
static int SECOND 
get和 set字段编号表示分钟内的第二个。  
static int SEPTEMBER 
MONTH字段的值代表了 公历和朱利安日历中的第九个月。   
protected long time 
这个日历的当前设定时间,以197011日,格林尼治标准时间0:00:00之后的毫秒表示。  
static int WEEK_OF_MONTH 
get和 set字段编号, set当月的周数。  
static int WEEK_OF_YEAR 
get和 set字段编号, set本年度的周数。  
static int YEAR 
get现场编号和 set表示年份。  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

注意事项:

  1. 月份不是从1开始,而是从0开始的,也就是说1月的表示数字为0

  2. 星期日表示的数字为1,星期六的表示数字为7

    Calendar c = Calendar.getInstance();
    c.set(2022, 2, 27, 10, 10, 10);
    System.out.println(c.get(Calendar.DAY_OF_WEEK));
    System.out.println(c.getTime());
    
    • 1
    • 2
    • 3
    • 4

在这里插入图片描述

Calendar c = Calendar.getInstance();
c.set(2022, 2, 27, 10, 10, 10);
System.out.println(c.get(Calendar.DAY_OF_WEEK));
System.out.println(c.getTime());
  • 1
  • 2
  • 3
  • 4

在这里插入图片描述

  1. 设置时间戳的时候如果想得到中国的时间(就是你要用的)那么就要减掉8个小时,具体为什么我也不知道。

    Calendar c = Calendar.getInstance();
    c.setTimeInMillis(0L);
    System.out.println(c.getTime());
    
    • 1
    • 2
    • 3

在这里插入图片描述

有了Calendar这个类,我们做一些日期处理的题的时候就会十分顺利,下面引入一道真题,如下所示:

真题链接

import java.util.Calendar;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        long t = s.nextLong();
        long offset = 8 * 60 * 60 * 1000;  //这里要减掉8个小时
        t -= offset;
        Calendar c = Calendar.getInstance();
        c.setTimeInMillis(t);
        System.out.printf("%02d:%02d:%02d\n",c.get(Calendar.HOUR_OF_DAY), c.get(Calendar.MINUTE), c.get(Calendar.SECOND));
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

Eclipse使用

代码提示和自动补全
对于编程人员来说,要记住大量的类名或类方法的名字,着实不是一件容易的事情。如果要IDE能够自动补全代码,那将为我们编程人员带来很大帮助。

eclipse代码里面的代码提示功能默认是关闭的,只有输入“.”的时候才会提示功能,下面说一下如何修改eclipse配置:

开启代码自动提示功能打开 Window -> Perferences -> Java ->Editor -> Content Assist,在右边最下面一栏找到 auto-Activation ,下面有三个选项,找到第二个“Auto activation triggers for Java:”选项在其后的文本框中会看到一个“.”存在。这表示:只有输入“.”之后才会有代码提示和自动补全,我们要修改的地方就是这。把该文本框中的“.”换掉,换成“abcdefghijklmnopqrstuvwxyz.”,这样,你在Eclipse里面写Java代码就可以做到按“abcdefghijklmnopqrstuvwxyz.”中的任意一个字符都会有代码提示。在这里插入图片描述

代码自动保存

1.第一步:window-> Perferences-> General->WorkPlace -> build :勾选Save automatically before manual build

在这里插入图片描述

2.第二步:window-> Perferences->Run/Debug -> Launching:在Save required dirty…下勾选always

在这里插入图片描述

常用快捷键
  1. ctrl+2,L:为本地变量赋值

注:ctrl和2同时按完以后释放,再快速按L。不能同时按!

  1. Alt+方向键

这也是个节省时间的法宝。这个组合将当前行的内容往上或下移动。

  1. ctrl+m

大显示屏幕能够提高工作效率是大家都知道的。Ctrl+m是编辑器窗口最大化的快捷键。

  1. ctrl+.及ctrl+1:下一个错误及快速修改

ctrl+.将光标移动至当前文件中的下一个报错处或警告处。这组快捷键我一般与ctrl+1一并使用,即修改建议的快捷键。

5.代码助手:Ctrl+Space(简体中文操作系统是Alt+/)

6.Ctrl+D: 删除当前行

7.Ctrl+shift+F:格式化当前代码

8.Alt+Shift+Z:包裹选中的代码

代码模板

syso 加内容辅助快捷键:alt+/,System.out.println();
for或者foreach 加内容辅助快捷键:alt+/,快速构建for循环
main:加内容辅助快捷键:alt+/,快速构建主函数
注意:

除了使用alt+‘/’, Eclipse默认还提供了很多代码模板。打开 Windows->Preferences->Java->Editor->Templates,可以看到所有已定义的代码模板列表。

在这里插入图片描述

调试的相关快捷键

F5 单步跳入
F6 单步跳过
F7 单步返回
F8 继续
Ctrl+Shift+D 显示变量的值
Ctrl+Shift+B 在当前行设置或者去掉断点
Ctrl+R 运行至行(超好用,可以节省好多的断点)

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/2023面试高手/article/detail/481080
推荐阅读
相关标签
  

闽ICP备14008679号