Java中的一些零星容易被忽略的API（及时补充）

最新推荐文章于 2024-07-03 02:40:39 发布

up-dayday

最新推荐文章于 2024-07-03 02:40:39 发布

阅读量210

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/weixin_42688876/article/details/81673272

本文介绍了Java中易被忽略的API，包括Arrays.copyOfRange()方法用于高效复制数组，String.charAt()获取指定索引的字符，以及深入探讨了Java中字符串的比较，包括==和equals的区别，同时讲解了栈、队列的实现和Collections的常见用法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

关于Java中的Arrays.copyOfRange()方法

要使用这个方法，首先要import java.util.*;

Arrays.copyOfRange(T[]original,int from,int to)

将一个原始的数值original，从小标from开始复制，复制到小标to，生成一个新的数组（注意这里包括下标from，不包括下标to）

这个方法在一些处理数组的编程题里很好用，效率和clone基本一致，都是native method，比利用循环复制数组效率要高得多。

Java String charAt()方法

此方法返回位于字符串的指定索引处的字符。该字符串的索引从零开始。

1 public class Test {
2 
3    public static void main(String args[]) {
4       String s = "Strings are immutable";
5       char result = s.charAt(8);
6       System.out.println(result);
7    }
8 }

这结果:a

java之从字符串比较到==和equals方法区别

我们先看代码

String str1 = new String("hello");

String str2 = "hello";

System.out.println("str1==str2： " + (str1==str2)); \\1

System.out.println("str1.equals(str2)： " + str1.equals(str2)); \\2

输出结果：

str1==str2： false

str1.equals(str2)： true

关于==和equals，我们需要知道java中的数据类型，可分为两类：

1.基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean
他们之间的比较，应用双等号（==）,比较的是他们的值。
2.复合数据类型(类)
当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。 JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。
对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的，因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。

　　因为string属于符合数据类型，所以应该是使用equals，假如我们使用==比较，肯定是比较它们的内存地址了，所以\\1 \\2 的结果显而易见了

　　要想判断两个对象是否相等，不能通过比较两个对象的引用是否相等，这是永远都得不到相等的结果的，因为两个对象的引用永远不会相等，所以正确的比较方法是直接比较这两个对象，比较这两个对象的实质是不是一样的，即这两个对象里面的内容是不是相同的，通过比较这两个对象的属性值是否相同而决定这两个对象是否相等。

　　Object类提供了一个equals()方法来比较两个对象的内容是否相同，因此我们可以采用这个方法去比较两个对象是否在逻辑上“相等”。如：c1.equals(c2);这里是调用从Object类继承下来的equals()方法，通过查阅API文档得到Object类里的equals方法的定义如下：
public boolean equals(Object obj)
注意，在重写equals方法时，需要按照以下几个规则设计：

1自反性：对任意引用值X，x.equals(x)的返回值一定为true.
2对称性：对于任何引用值x,y,当且仅当y.equals(x)返回值为true时，x.equals(y)的返回值一定为true;
3传递性：如果x.equals(y)=true, y.equals(z)=true,则x.equals(z)=true
4一致性：如果参与比较的对象没任何改变，则对象比较的结果也不应该有任何改变
5非空性：任何非空的引用值X，x.equals(null)的返回值一定为false

再看代码：

String str2 = "hello";

String str3 = "hello";

System.out.println("str3==str2： " + (str3==str2)); \\3

System.out.println("str3.equals(str2)： " + str3.equals(str2)); \\4

输出结果：

str3==str2： true

str3.equals(str2)： true

这里的又为什么都是输出true呢，因为它们都是从缓冲池取出来的，由于string类比较特殊，jdk专门做了缓存优化。

　　原来Java运行时会维护一个String Pool（String池）。String池用来存放运行时中产生的各种字符串，并且池中的字符串的内容不重复。而一般对象不存在这个缓冲池，并且创建的对象仅仅存在于方法的堆栈区。
也就是说需要看string创建的方式：

1 当使用任何方式来创建一个字符串对象s时，Java运行时（运行中JVM）会拿着这个X在String池中找是否存在内容相同的字符串对象，如果不存在，则在池中创建一个字符串s，否则，不在池中添加。
2 Java中，只要使用new关键字来创建对象，则一定会（在堆区或栈区）创建一个新的对象。
3 使用直接指定或者使用纯字符串串联来创建String对象，则仅仅会检查维护String池中的字符串，池中没有就在池中创建一个，有则罢了！但绝不会在堆栈区再去创建该String对象。
4 使用包含变量的表达式来创建String对象，则不仅会检查维护String池，而且还会在堆栈区创建一个String对象。
　　另外，String的intern()方法是一个本地方法，定义为public native String intern(); intern()方法的价值在于让开发者能将注意力集中到String池上。当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（该对象由 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并且返回此 String 对象的引用。

java中栈和队列的实现和API的用法(详解)

一、栈的实现

栈的实现，有两个方法：一个是用java本身的集合类型Stack类型；另一个是借用LinkedList来间接实现Stack。

1.Stack实现

直接用Stack来实现非常方便，常用的api函数如下：

boolean        isEmpty() // 判断当前栈是否为空
synchronized E        peek() //获得当前栈顶元素
synchronized E        pop() //获得当前栈顶元素并删除
             E        push(E object) //将元素加入栈顶
synchronized int      search(Object o) //查找元素在栈中的位置，由栈低向栈顶方向数2.LinkedList实现
LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
LinkedList 实现 List 接口，能对它进行队列操作。
LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。

当LinkedList被当做栈来使用时，常用api及对应关系如下：

栈方法        等效方法
push(e)      addFirst(e)
pop()        removeFirst()
peek()       peekFirst()      isEmpty() //判断是否为空

二、队列的实现

java中虽然有Queue接口，单java并没有给出具体的队列实现类，而Java中让LinkedList类实现了Queue接口，所以使用队列的时候，一般采用LinkedList。因为LinkedList是双向链表，可以很方便的实现队列的所有功能。

Queue使用时要尽量避免Collection的add()和remove()方法，而是要使用offer()来加入元素，使用poll()来获取并移出元素。它们的优点是通过返回值可以判断成功与否，add()和remove()方法在失败的时候会抛出异常。如果要使用前端而不移出该元素，使用element()或者peek()方法。

java中定义队列一般这样定义： Queue<E> queue = new LinkedList<E>();

当采用LinkedList来实现时，api的使用和对用关系如下：

队列方法       等效方法
offer(e)      offer(e)/offerLast(e) //进队列，将元素加入队列末尾
poll()        poll()/pollFirst() //获取队列头的元素并移除
peek()        peek()/peekFirst() //获取队列头的元素       isEmpty() //判断是否为空

collections在java中的常见用法

1）排序（Sort）

使用sort方法可以根据元素的自然顺序对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此列表内的所有元素都必须是使用指定比较器可相互比较的

double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.sort(list);
for (int i = 0; i < array.length; i++) {
System.out.println(li.get(i));
}
//结果：112,111,23,456,231

2）混排（Shuffling）

混排算法所做的正好与 sort 相反：它打乱在一个 List 中可能有的任何排列的踪迹。也就是说，基于随机源的输入重排该 List，这样的排列具有相同的可能性（假设随机源是公正的）。这个算法在实现一个碰运气的游戏中是非常有用的。例如，它可被用来混排代表一副牌的 Card 对象的一个 List .另外，在生成测试案例时，它也是十分有用的。

Collections.Shuffling(list)
double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.shuffle(list);
for (int i = 0; i < array.length; i++) {
System.out.println(li.get(i));
}
//结果：112,111,23,456,231

3）反转（Reverse）

使用Reverse方法可以根据元素的自然顺序对指定列表按降序进行排序。

Collections.reverse(list)
double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections. reverse (list);
for (int i = 0; i < array.length; i++) {
System.out.println(li.get(i));
}
//结果：231,456,23,111,112

4）替换所有的元素（Fill）

使用指定元素替换指定列表中的所有元素。

String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j
li.add(new String(str[j]));
}
Collections.fill(li,"aaa");
for (int i = 0; i < li.size(); i++) {
System.out.println("list[" + i + "]=" + li.get(i));

}
//结果：aaa,aaa,aaa,aaa,aaa

5）拷贝（Copy）

用两个参数，一个目标 List 和一个源 List，将源的元素拷贝到目标，并覆盖它的内容。目标 List 至少与源一样长。如果它更长，则在目标 List 中的剩余元素不受影响。

Collections.copy（list，li）：后面一个参数是目标列表，前一个是源列表

double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
List li = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
double arr[] = {1131,333};
String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j
li.add(new Double(arr[j]));
}
Collections.copy(list,li);
for (int i = 0; i
System.out.println("list[" + i + "]=" + list.get(i));
}
//结果：1131,333,23,456,231

6）返回Collections中最小元素（min）

根据指定比较器产生的顺序，返回给定 collection 的最小元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

Collections.min(list)
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.min(list);
for (int i = 0; i
System.out.println("list[" + i + "]=" + list.get(i));
}
//结果：23

7）返回Collections中最大元素（max）

根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

Collections.max(list)
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.max(list);
for (int i = 0; i
System.out.println("list[" + i + "]=" + list.get(i));
}
//结果：456