Java Arrays工具类用法详解

Java Arrays工具类用法详解

本文实例讲述了java Arrays工具类用法。分享给大家供大家参考，具体如下：

Arrays类

功能描述

Arrays类是一个工具类，其中包含了数组操作的很多方法，比如搜索和排序；

Arrays类中的方法均为static修饰的，可以直接通过Arrays.xxx(xxx)的形式调用方法。

几个重要方法

1.asList(T... a)

由给定的数组a，返回一个固定大小的List对象。在这里，着重解释一下前面这句话的深层含义，我们可以看Arrays类的源码，来帮助我们理解。

生成的List对象，是由所给的数组a来决定的，我们看一下源码实现：

public static List asList(T... a) {

return new ArrayList<>(a);

}

return new ArrayList<>(a);

}

而这个ArrayList并不是java.util中的ArrayList类，而是Arrays的内部类ArrayList，源码为：

private static class ArrayList extends AbstractList

implements RandomAccess, java.io.Serializable

{

private static final long serialVersionUID = -2764017481108945198L;

private final E[] a;

ArrayList(E[] array) {

a = Objects.requireNonNull(array);

}

@Override

public int size() {

return a.length;

}

@Override

public Object[] toArray() {

return a.clone();

}

@Override

@SuppressWarnings("unchecked")

public T[] toArray(T[] a) {

int size = size();

if (a.length < size)

return Arrays.copyOf(this.a, size,

(Class extends T[]>) a.getClass());

System.arraycopy(this.a, 0, a, 0, size);

if (a.length > size)

a[size] = null;

return a;

}

@Override

public E http://get(int index) {

return a[index];

}

@Override

public E set(int index, E element) {

E oldValue = a[index];

a[index] = element;

return oldValue;

}

@Override

public int indexOf(Object o) {

E[] a = this.a;

if (o == null) {

for (int i = 0; i < a.length; i++)

if (a[i] == null)

return i;

} else {

for (int i = 0; i < a.length; i++)

if (o.equals(a[i]))

return i;

}

return -1;

}

@Override

public boolean contains(Object o) {

return indexOf(o) != -1;

}

@Override

public Spliterator spliterator() {

return Spliterators.spliterator(a, Spliterator.ORDERED);

}

@Override

public void forEach(Consumer super E> action) {

Objects.requireNonNull(action);

for (E e : a) {

action.accept(e);

}

}

@Override

public void replaceAll(UnaryOperator operator) {

Objects.requireNonNull(operator);

E[] a = this.a;

for (int i = 0; i < a.length; i++) {

a[i] = operator.apply(a[i]);

}

}

@Override

public void sort(Comparator super E> c) {

Arrays.sort(a, c);

}

}

public static T requireNonNull(T obj) {

if (obj == null)

throw new NullPointerException();

return obj;

}

所以，可以看出，最后生成的List实例的元素与数组a中的元素是一样的，并且，其长度和数组a的元素一样。

现在解释一下“固定长度的意思”：

List与数组的一个区别是，List的长度是可变的，可以对List进行插入和删除元素，数组的长度是固定的，而且不能从数组中删除元素，只能修改元素的值。利用Arrays.asList(array)将返回一个List，然而这个返回的List并不支持add和remove的操作。

那为什么不支持add和remove操作呢？只能上源码了：

我们在AbstractList中找到依据，如何实现插入和删除元素：

public boolean add(E e) {

add(size(), e);

return true;

}

public void add(int index, E element) {

throw new UnsupportedOperationException();

}

public E remove(int index) {

throw new UnsupportedOperationException();

}

所以当我们通过asList()方法生成一个列表实例时，对该实例进行插入和删除元素是会有异常的。同时也说明了生成的List对象的大小是由原来给定的数组决定的。

自己做的测试：

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

public class ArraysTest

{

public static void main(String[] args)

{

Integer[] a = {1,2,3,4};

int[] b = {1,2,3,4};

String[] str = {"a","s","d"};

List list1 = null;

List list2 = null;

List list3 = null;

list1 = Arrays.asList(a);

list2 = Arrays.asList(str);

list3 = Arrays.asList(b);

System.out.println("list1的大小："+list1.size());

System.out.println("list2的大小："+list2.size());

System.out.println("list3的大小："+list3.size());//注意，如果原数组的元素为基本数据类型，那么生成的list大小为1

System.out.println("--------原始数组的信息----------");

System.out.print("a的内容：");

for(int i= 0; i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("str的内容：");

for(int i= 0; i

{

System.out.print(str[i]+",");

}

System.out.print("\n");

System.out.println("--------生成的list的信息----------");

System.out.print("list1的内容：");

Iterator ite = list1.iterator();

while(ite.hasNext())

{

System.out.print((Integer)ite.next()+",");

}

System.out.print("\n");

System.out.println("list1的大小："+list1.size());

System.out.print("list2的内容：");

Iterator ite1 = list2.iterator();

while(ite1.hasNext())

{

System.out.print(ite1.next().toString()+",");

}

System.out.print("\n");

System.out.println("list2的大小："+list2.size());

list1.set(1,new Integer(23));

a[0] = new Integer(90);

System.out.println("--------修改后的信息----------");

System.out.print("a的内容:");

for(int i= 0; i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("list1的内容:");

Iterator ite2 = list1.iterator();

while(ite2.hasNext())

{

System.out.print((Integer)ite2.next()+",");

}

System.out.print("\n");

list1.add(new Integer(6));

System.out.println("------------------------");

System.out.println("list1的大小："+list1.size());

System.out.println("------------------------");

list1.add(2,new Integer(9));

list1.remove(3);

}

}

结果截图：

可以看出，当改变原数组中的元素时，会导致list对象中的相应元素发生改变；同样的，当生成的list对象中的元素做修改时，也会导致原来数组中相应的元素发生改变。

2.fill():

给定特定值val，使整个数组中或者某下标范围内的元素值为val

以int数组来分析，其他类型的数组

练习源码：

import java.util.Arrays;

public class ArraysTest04

{

public static void main(String[] args)

{

int[] a = new int[7];

int[] b = new int[7];

Arrays.fill(a,3);

Arrays.fill(b,3,5,6);

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(b[i]+",");

}

System.out.print("\n");

}

}

结果截图：

3.copyOf() && copyOfRange()

copyOf()：将原始数组的元素，复制到新的数组中，可以设置复制的长度（即需要被复制的元素个数）。

copyOfRange()：将某个范围内的元素复制到新的数组中。

以int数组来分析，其他类型的数组

练习源码：

import java.util.Arrays;

public class ArraysTest03

{

public static void main(String[] args)

{

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

int[] b;

int[] c;

int[] d;

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

b = Arrays.copyOf(a,7);//将a数组的内容复制到b数组中，如果新的数组长度大于原来数组的长度，那么用0来填充

c = Arrays.copyOf(a,3);

d = Arrays.copyOfRange(a,2,4);

System.out.println("-----------复制数组---------");

for(int i = 0;i

{

System.out.print(b[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(c[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(d[i]+",");

}

System.out.print("\n");

}

}

结http://果截图：

4.equals()

判断两个数组中的元素是否一一对应相等

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraaysTest05

{

public static void main(String[] args)

{

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

int[] b = null;

int[] c = new int[]{};

int[] d = new int[]{1,2,3};

System.out.println(Arrays.equals(a,b));

System.out.println(Arrays.equals(a,c));

System.out.println(Arrays.equals(a,d));

System.out.println(Arrays.equals(b,c));

System.out.println(Arrays.equals(b,d));

System.out.println(Arrays.equals(c,d));

}

}

结果截图：

5.sort():

对数组进行升序排序，排序后 ，数组中存放的是排序后的结果

以int数组来分析，其他类型的数组原理一样

练习代码：

import java.util.Arrays;

public class ArraysTest05

{

public static void main(String[] args)

{

int[] a ={34,56,23,565,23,-56};

Arrays.sort(a);

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

}

}

结果截图：

6.binarySearch()

对排序好的数组，采用二分查找的方式查找某个元素，可以在整个数组中查找，也可以在某个范围内查找。

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraysTest02

{

public static void main(String[] args)

{

int[] a = {1,45,78,23,123,98,67,12,90,56};

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

Arrays.sort(a);

System.out.println("-----------排序后数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("在整个数组中寻找：");

System.out.println(Arrays.binarySearch(a,78));

System.out.print("在局部范围内寻找：");

System.out.println(Arrays.binarySearch(a,4,7,1));

}

}

结果截图：

更多关于java相关内容感兴趣的读者可查看本站专题：《Java数组操作技巧总结》、《Java字符与字符串操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》

希望本文所述对大家java程序设计有所帮助。

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("str的内容：");

for(int i= 0; i

{

System.out.print(str[i]+",");

}

System.out.print("\n");

System.out.println("--------生成的list的信息----------");

System.out.print("list1的内容：");

Iterator ite = list1.iterator();

while(ite.hasNext())

{

System.out.print((Integer)ite.next()+",");

}

System.out.print("\n");

System.out.println("list1的大小："+list1.size());

System.out.print("list2的内容：");

Iterator ite1 = list2.iterator();

while(ite1.hasNext())

{

System.out.print(ite1.next().toString()+",");

}

System.out.print("\n");

System.out.println("list2的大小："+list2.size());

list1.set(1,new Integer(23));

a[0] = new Integer(90);

System.out.println("--------修改后的信息----------");

System.out.print("a的内容:");

for(int i= 0; i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("list1的内容:");

Iterator ite2 = list1.iterator();

while(ite2.hasNext())

{

System.out.print((Integer)ite2.next()+",");

}

System.out.print("\n");

list1.add(new Integer(6));

System.out.println("------------------------");

System.out.println("list1的大小："+list1.size());

System.out.println("------------------------");

list1.add(2,new Integer(9));

list1.remove(3);

}

}

结果截图：

可以看出，当改变原数组中的元素时，会导致list对象中的相应元素发生改变；同样的，当生成的list对象中的元素做修改时，也会导致原来数组中相应的元素发生改变。

2.fill():

给定特定值val，使整个数组中或者某下标范围内的元素值为val

以int数组来分析，其他类型的数组

练习源码：

import java.util.Arrays;

public class ArraysTest04

{

public static void main(String[] args)

{

int[] a = new int[7];

int[] b = new int[7];

Arrays.fill(a,3);

Arrays.fill(b,3,5,6);

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(b[i]+",");

}

System.out.print("\n");

}

}

结果截图：

3.copyOf() && copyOfRange()

copyOf()：将原始数组的元素，复制到新的数组中，可以设置复制的长度（即需要被复制的元素个数）。

copyOfRange()：将某个范围内的元素复制到新的数组中。

以int数组来分析，其他类型的数组

练习源码：

import java.util.Arrays;

public class ArraysTest03

{

public static void main(String[] args)

{

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

int[] b;

int[] c;

int[] d;

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

b = Arrays.copyOf(a,7);//将a数组的内容复制到b数组中，如果新的数组长度大于原来数组的长度，那么用0来填充

c = Arrays.copyOf(a,3);

d = Arrays.copyOfRange(a,2,4);

System.out.println("-----------复制数组---------");

for(int i = 0;i

{

System.out.print(b[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(c[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(d[i]+",");

}

System.out.print("\n");

}

}

结http://果截图：

4.equals()

判断两个数组中的元素是否一一对应相等

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraaysTest05

{

public static void main(String[] args)

{

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

int[] b = null;

int[] c = new int[]{};

int[] d = new int[]{1,2,3};

System.out.println(Arrays.equals(a,b));

System.out.println(Arrays.equals(a,c));

System.out.println(Arrays.equals(a,d));

System.out.println(Arrays.equals(b,c));

System.out.println(Arrays.equals(b,d));

System.out.println(Arrays.equals(c,d));

}

}

结果截图：

5.sort():

对数组进行升序排序，排序后 ，数组中存放的是排序后的结果

以int数组来分析，其他类型的数组原理一样

练习代码：

import java.util.Arrays;

public class ArraysTest05

{

public static void main(String[] args)

{

int[] a ={34,56,23,565,23,-56};

Arrays.sort(a);

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

}

}

结果截图：

6.binarySearch()

对排序好的数组，采用二分查找的方式查找某个元素，可以在整个数组中查找，也可以在某个范围内查找。

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraysTest02

{

public static void main(String[] args)

{

int[] a = {1,45,78,23,123,98,67,12,90,56};

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

Arrays.sort(a);

System.out.println("-----------排序后数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("在整个数组中寻找：");

System.out.println(Arrays.binarySearch(a,78));

System.out.print("在局部范围内寻找：");

System.out.println(Arrays.binarySearch(a,4,7,1));

}

}

结果截图：

更多关于java相关内容感兴趣的读者可查看本站专题：《Java数组操作技巧总结》、《Java字符与字符串操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》

希望本文所述对大家java程序设计有所帮助。

{

System.out.print(str[i]+",");

}

System.out.print("\n");

System.out.println("--------生成的list的信息----------");

System.out.print("list1的内容：");

Iterator ite = list1.iterator();

while(ite.hasNext())

{

System.out.print((Integer)ite.next()+",");

}

System.out.print("\n");

System.out.println("list1的大小："+list1.size());

System.out.print("list2的内容：");

Iterator ite1 = list2.iterator();

while(ite1.hasNext())

{

System.out.print(ite1.next().toString()+",");

}

System.out.print("\n");

System.out.println("list2的大小："+list2.size());

list1.set(1,new Integer(23));

a[0] = new Integer(90);

System.out.println("--------修改后的信息----------");

System.out.print("a的内容:");

for(int i= 0; i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("list1的内容:");

Iterator ite2 = list1.iterator();

while(ite2.hasNext())

{

System.out.print((Integer)ite2.next()+",");

}

System.out.print("\n");

list1.add(new Integer(6));

System.out.println("------------------------");

System.out.println("list1的大小："+list1.size());

System.out.println("------------------------");

list1.add(2,new Integer(9));

list1.remove(3);

}

}

结果截图：

可以看出，当改变原数组中的元素时，会导致list对象中的相应元素发生改变；同样的，当生成的list对象中的元素做修改时，也会导致原来数组中相应的元素发生改变。

2.fill():

给定特定值val，使整个数组中或者某下标范围内的元素值为val

以int数组来分析，其他类型的数组

练习源码：

import java.util.Arrays;

public class ArraysTest04

{

public static void main(String[] args)

{

int[] a = new int[7];

int[] b = new int[7];

Arrays.fill(a,3);

Arrays.fill(b,3,5,6);

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(b[i]+",");

}

System.out.print("\n");

}

}

结果截图：

3.copyOf() && copyOfRange()

copyOf()：将原始数组的元素，复制到新的数组中，可以设置复制的长度（即需要被复制的元素个数）。

copyOfRange()：将某个范围内的元素复制到新的数组中。

以int数组来分析，其他类型的数组

练习源码：

import java.util.Arrays;

public class ArraysTest03

{

public static void main(String[] args)

{

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

int[] b;

int[] c;

int[] d;

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

b = Arrays.copyOf(a,7);//将a数组的内容复制到b数组中，如果新的数组长度大于原来数组的长度，那么用0来填充

c = Arrays.copyOf(a,3);

d = Arrays.copyOfRange(a,2,4);

System.out.println("-----------复制数组---------");

for(int i = 0;i

{

System.out.print(b[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(c[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(d[i]+",");

}

System.out.print("\n");

}

}

结http://果截图：

4.equals()

判断两个数组中的元素是否一一对应相等

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraaysTest05

{

public static void main(String[] args)

{

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

int[] b = null;

int[] c = new int[]{};

int[] d = new int[]{1,2,3};

System.out.println(Arrays.equals(a,b));

System.out.println(Arrays.equals(a,c));

System.out.println(Arrays.equals(a,d));

System.out.println(Arrays.equals(b,c));

System.out.println(Arrays.equals(b,d));

System.out.println(Arrays.equals(c,d));

}

}

结果截图：

5.sort():

对数组进行升序排序，排序后 ，数组中存放的是排序后的结果

以int数组来分析，其他类型的数组原理一样

练习代码：

import java.util.Arrays;

public class ArraysTest05

{

public static void main(String[] args)

{

int[] a ={34,56,23,565,23,-56};

Arrays.sort(a);

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

}

}

结果截图：

6.binarySearch()

对排序好的数组，采用二分查找的方式查找某个元素，可以在整个数组中查找，也可以在某个范围内查找。

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraysTest02

{

public static void main(String[] args)

{

int[] a = {1,45,78,23,123,98,67,12,90,56};

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

Arrays.sort(a);

System.out.println("-----------排序后数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("在整个数组中寻找：");

System.out.println(Arrays.binarySearch(a,78));

System.out.print("在局部范围内寻找：");

System.out.println(Arrays.binarySearch(a,4,7,1));

}

}

结果截图：

更多关于java相关内容感兴趣的读者可查看本站专题：《Java数组操作技巧总结》、《Java字符与字符串操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》

希望本文所述对大家java程序设计有所帮助。

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("list1的内容:");

Iterator ite2 = list1.iterator();

while(ite2.hasNext())

{

System.out.print((Integer)ite2.next()+",");

}

System.out.print("\n");

list1.add(new Integer(6));

System.out.println("------------------------");

System.out.println("list1的大小："+list1.size());

System.out.println("------------------------");

list1.add(2,new Integer(9));

list1.remove(3);

}

}

结果截图：

可以看出，当改变原数组中的元素时，会导致list对象中的相应元素发生改变；同样的，当生成的list对象中的元素做修改时，也会导致原来数组中相应的元素发生改变。

2.fill():

给定特定值val，使整个数组中或者某下标范围内的元素值为val

以int数组来分析，其他类型的数组

练习源码：

import java.util.Arrays;

public class ArraysTest04

{

public static void main(String[] args)

{

int[] a = new int[7];

int[] b = new int[7];

Arrays.fill(a,3);

Arrays.fill(b,3,5,6);

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(b[i]+",");

}

System.out.print("\n");

}

}

结果截图：

3.copyOf() && copyOfRange()

copyOf()：将原始数组的元素，复制到新的数组中，可以设置复制的长度（即需要被复制的元素个数）。

copyOfRange()：将某个范围内的元素复制到新的数组中。

以int数组来分析，其他类型的数组

练习源码：

import java.util.Arrays;

public class ArraysTest03

{

public static void main(String[] args)

{

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

int[] b;

int[] c;

int[] d;

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

b = Arrays.copyOf(a,7);//将a数组的内容复制到b数组中，如果新的数组长度大于原来数组的长度，那么用0来填充

c = Arrays.copyOf(a,3);

d = Arrays.copyOfRange(a,2,4);

System.out.println("-----------复制数组---------");

for(int i = 0;i

{

System.out.print(b[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(c[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(d[i]+",");

}

System.out.print("\n");

}

}

结http://果截图：

4.equals()

判断两个数组中的元素是否一一对应相等

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraaysTest05

{

public static void main(String[] args)

{

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

int[] b = null;

int[] c = new int[]{};

int[] d = new int[]{1,2,3};

System.out.println(Arrays.equals(a,b));

System.out.println(Arrays.equals(a,c));

System.out.println(Arrays.equals(a,d));

System.out.println(Arrays.equals(b,c));

System.out.println(Arrays.equals(b,d));

System.out.println(Arrays.equals(c,d));

}

}

结果截图：

5.sort():

对数组进行升序排序，排序后 ，数组中存放的是排序后的结果

以int数组来分析，其他类型的数组原理一样

练习代码：

import java.util.Arrays;

public class ArraysTest05

{

public static void main(String[] args)

{

int[] a ={34,56,23,565,23,-56};

Arrays.sort(a);

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

}

}

结果截图：

6.binarySearch()

对排序好的数组，采用二分查找的方式查找某个元素，可以在整个数组中查找，也可以在某个范围内查找。

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraysTest02

{

public static void main(String[] args)

{

int[] a = {1,45,78,23,123,98,67,12,90,56};

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

Arrays.sort(a);

System.out.println("-----------排序后数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("在整个数组中寻找：");

System.out.println(Arrays.binarySearch(a,78));

System.out.print("在局部范围内寻找：");

System.out.println(Arrays.binarySearch(a,4,7,1));

}

}

结果截图：

更多关于java相关内容感兴趣的读者可查看本站专题：《Java数组操作技巧总结》、《Java字符与字符串操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》

希望本文所述对大家java程序设计有所帮助。

{

System.out.print(a[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(b[i]+",");

}

System.out.print("\n");

}

}

结果截图：

3.copyOf() && copyOfRange()

copyOf()：将原始数组的元素，复制到新的数组中，可以设置复制的长度（即需要被复制的元素个数）。

copyOfRange()：将某个范围内的元素复制到新的数组中。

以int数组来分析，其他类型的数组

练习源码：

import java.util.Arrays;

public class ArraysTest03

{

public static void main(String[] args)

{

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

int[] b;

int[] c;

int[] d;

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

b = Arrays.copyOf(a,7);//将a数组的内容复制到b数组中，如果新的数组长度大于原来数组的长度，那么用0来填充

c = Arrays.copyOf(a,3);

d = Arrays.copyOfRange(a,2,4);

System.out.println("-----------复制数组---------");

for(int i = 0;i

{

System.out.print(b[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(c[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(d[i]+",");

}

System.out.print("\n");

}

}

结http://果截图：

4.equals()

判断两个数组中的元素是否一一对应相等

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraaysTest05

{

public static void main(String[] args)

{

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

int[] b = null;

int[] c = new int[]{};

int[] d = new int[]{1,2,3};

System.out.println(Arrays.equals(a,b));

System.out.println(Arrays.equals(a,c));

System.out.println(Arrays.equals(a,d));

System.out.println(Arrays.equals(b,c));

System.out.println(Arrays.equals(b,d));

System.out.println(Arrays.equals(c,d));

}

}

结果截图：

5.sort():

对数组进行升序排序，排序后 ，数组中存放的是排序后的结果

以int数组来分析，其他类型的数组原理一样

练习代码：

import java.util.Arrays;

public class ArraysTest05

{

public static void main(String[] args)

{

int[] a ={34,56,23,565,23,-56};

Arrays.sort(a);

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

}

}

结果截图：

6.binarySearch()

对排序好的数组，采用二分查找的方式查找某个元素，可以在整个数组中查找，也可以在某个范围内查找。

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraysTest02

{

public static void main(String[] args)

{

int[] a = {1,45,78,23,123,98,67,12,90,56};

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

Arrays.sort(a);

System.out.println("-----------排序后数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("在整个数组中寻找：");

System.out.println(Arrays.binarySearch(a,78));

System.out.print("在局部范围内寻找：");

System.out.println(Arrays.binarySearch(a,4,7,1));

}

}

结果截图：

更多关于java相关内容感兴趣的读者可查看本站专题：《Java数组操作技巧总结》、《Java字符与字符串操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》

希望本文所述对大家java程序设计有所帮助。

{

System.out.print(b[i]+",");

}

System.out.print("\n");

}

}

结果截图：

3.copyOf() && copyOfRange()

copyOf()：将原始数组的元素，复制到新的数组中，可以设置复制的长度（即需要被复制的元素个数）。

copyOfRange()：将某个范围内的元素复制到新的数组中。

以int数组来分析，其他类型的数组

练习源码：

import java.util.Arrays;

public class ArraysTest03

{

public static void main(String[] args)

{

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

int[] b;

int[] c;

int[] d;

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

b = Arrays.copyOf(a,7);//将a数组的内容复制到b数组中，如果新的数组长度大于原来数组的长度，那么用0来填充

c = Arrays.copyOf(a,3);

d = Arrays.copyOfRange(a,2,4);

System.out.println("-----------复制数组---------");

for(int i = 0;i

{

System.out.print(b[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(c[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(d[i]+",");

}

System.out.print("\n");

}

}

结http://果截图：

4.equals()

判断两个数组中的元素是否一一对应相等

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraaysTest05

{

public static void main(String[] args)

{

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

int[] b = null;

int[] c = new int[]{};

int[] d = new int[]{1,2,3};

System.out.println(Arrays.equals(a,b));

System.out.println(Arrays.equals(a,c));

System.out.println(Arrays.equals(a,d));

System.out.println(Arrays.equals(b,c));

System.out.println(Arrays.equals(b,d));

System.out.println(Arrays.equals(c,d));

}

}

结果截图：

5.sort():

对数组进行升序排序，排序后 ，数组中存放的是排序后的结果

以int数组来分析，其他类型的数组原理一样

练习代码：

import java.util.Arrays;

public class ArraysTest05

{

public static void main(String[] args)

{

int[] a ={34,56,23,565,23,-56};

Arrays.sort(a);

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

}

}

结果截图：

6.binarySearch()

对排序好的数组，采用二分查找的方式查找某个元素，可以在整个数组中查找，也可以在某个范围内查找。

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraysTest02

{

public static void main(String[] args)

{

int[] a = {1,45,78,23,123,98,67,12,90,56};

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

Arrays.sort(a);

System.out.println("-----------排序后数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("在整个数组中寻找：");

System.out.println(Arrays.binarySearch(a,78));

System.out.print("在局部范围内寻找：");

System.out.println(Arrays.binarySearch(a,4,7,1));

}

}

结果截图：

更多关于java相关内容感兴趣的读者可查看本站专题：《Java数组操作技巧总结》、《Java字符与字符串操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》

希望本文所述对大家java程序设计有所帮助。

{

System.out.print(a[i]+",");

}

System.out.print("\n");

b = Arrays.copyOf(a,7);//将a数组的内容复制到b数组中，如果新的数组长度大于原来数组的长度，那么用0来填充

c = Arrays.copyOf(a,3);

d = Arrays.copyOfRange(a,2,4);

System.out.println("-----------复制数组---------");

for(int i = 0;i

{

System.out.print(b[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(c[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(d[i]+",");

}

System.out.print("\n");

}

}

结http://果截图：

4.equals()

判断两个数组中的元素是否一一对应相等

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraaysTest05

{

public static void main(String[] args)

{

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

int[] b = null;

int[] c = new int[]{};

int[] d = new int[]{1,2,3};

System.out.println(Arrays.equals(a,b));

System.out.println(Arrays.equals(a,c));

System.out.println(Arrays.equals(a,d));

System.out.println(Arrays.equals(b,c));

System.out.println(Arrays.equals(b,d));

System.out.println(Arrays.equals(c,d));

}

}

结果截图：

5.sort():

对数组进行升序排序，排序后 ，数组中存放的是排序后的结果

以int数组来分析，其他类型的数组原理一样

练习代码：

import java.util.Arrays;

public class ArraysTest05

{

public static void main(String[] args)

{

int[] a ={34,56,23,565,23,-56};

Arrays.sort(a);

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

}

}

结果截图：

6.binarySearch()

对排序好的数组，采用二分查找的方式查找某个元素，可以在整个数组中查找，也可以在某个范围内查找。

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraysTest02

{

public static void main(String[] args)

{

int[] a = {1,45,78,23,123,98,67,12,90,56};

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

Arrays.sort(a);

System.out.println("-----------排序后数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("在整个数组中寻找：");

System.out.println(Arrays.binarySearch(a,78));

System.out.print("在局部范围内寻找：");

System.out.println(Arrays.binarySearch(a,4,7,1));

}

}

结果截图：

更多关于java相关内容感兴趣的读者可查看本站专题：《Java数组操作技巧总结》、《Java字符与字符串操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》

希望本文所述对大家java程序设计有所帮助。

{

System.out.print(b[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(c[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(d[i]+",");

}

System.out.print("\n");

}

}

结http://果截图：

4.equals()

判断两个数组中的元素是否一一对应相等

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraaysTest05

{

public static void main(String[] args)

{

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

int[] b = null;

int[] c = new int[]{};

int[] d = new int[]{1,2,3};

System.out.println(Arrays.equals(a,b));

System.out.println(Arrays.equals(a,c));

System.out.println(Arrays.equals(a,d));

System.out.println(Arrays.equals(b,c));

System.out.println(Arrays.equals(b,d));

System.out.println(Arrays.equals(c,d));

}

}

结果截图：

5.sort():

对数组进行升序排序，排序后 ，数组中存放的是排序后的结果

以int数组来分析，其他类型的数组原理一样

练习代码：

import java.util.Arrays;

public class ArraysTest05

{

public static void main(String[] args)

{

int[] a ={34,56,23,565,23,-56};

Arrays.sort(a);

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

}

}

结果截图：

6.binarySearch()

对排序好的数组，采用二分查找的方式查找某个元素，可以在整个数组中查找，也可以在某个范围内查找。

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraysTest02

{

public static void main(String[] args)

{

int[] a = {1,45,78,23,123,98,67,12,90,56};

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

Arrays.sort(a);

System.out.println("-----------排序后数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("在整个数组中寻找：");

System.out.println(Arrays.binarySearch(a,78));

System.out.print("在局部范围内寻找：");

System.out.println(Arrays.binarySearch(a,4,7,1));

}

}

结果截图：

更多关于java相关内容感兴趣的读者可查看本站专题：《Java数组操作技巧总结》、《Java字符与字符串操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》

希望本文所述对大家java程序设计有所帮助。

{

System.out.print(c[i]+",");

}

System.out.print("\n");

for(int i = 0;i

{

System.out.print(d[i]+",");

}

System.out.print("\n");

}

}

结http://果截图：

4.equals()

判断两个数组中的元素是否一一对应相等

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraaysTest05

{

public static void main(String[] args)

{

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

int[] b = null;

int[] c = new int[]{};

int[] d = new int[]{1,2,3};

System.out.println(Arrays.equals(a,b));

System.out.println(Arrays.equals(a,c));

System.out.println(Arrays.equals(a,d));

System.out.println(Arrays.equals(b,c));

System.out.println(Arrays.equals(b,d));

System.out.println(Arrays.equals(c,d));

}

}

结果截图：

5.sort():

对数组进行升序排序，排序后 ，数组中存放的是排序后的结果

以int数组来分析，其他类型的数组原理一样

练习代码：

import java.util.Arrays;

public class ArraysTest05

{

public static void main(String[] args)

{

int[] a ={34,56,23,565,23,-56};

Arrays.sort(a);

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

}

}

结果截图：

6.binarySearch()

对排序好的数组，采用二分查找的方式查找某个元素，可以在整个数组中查找，也可以在某个范围内查找。

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraysTest02

{

public static void main(String[] args)

{

int[] a = {1,45,78,23,123,98,67,12,90,56};

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

Arrays.sort(a);

System.out.println("-----------排序后数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("在整个数组中寻找：");

System.out.println(Arrays.binarySearch(a,78));

System.out.print("在局部范围内寻找：");

System.out.println(Arrays.binarySearch(a,4,7,1));

}

}

结果截图：

更多关于java相关内容感兴趣的读者可查看本站专题：《Java数组操作技巧总结》、《Java字符与字符串操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》

希望本文所述对大家java程序设计有所帮助。

{

System.out.print(d[i]+",");

}

System.out.print("\n");

}

}

结http://果截图：

4.equals()

判断两个数组中的元素是否一一对应相等

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraaysTest05

{

public static void main(String[] args)

{

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

int[] b = null;

int[] c = new int[]{};

int[] d = new int[]{1,2,3};

System.out.println(Arrays.equals(a,b));

System.out.println(Arrays.equals(a,c));

System.out.println(Arrays.equals(a,d));

System.out.println(Arrays.equals(b,c));

System.out.println(Arrays.equals(b,d));

System.out.println(Arrays.equals(c,d));

}

}

结果截图：

5.sort():

对数组进行升序排序，排序后 ，数组中存放的是排序后的结果

以int数组来分析，其他类型的数组原理一样

练习代码：

import java.util.Arrays;

public class ArraysTest05

{

public static void main(String[] args)

{

int[] a ={34,56,23,565,23,-56};

Arrays.sort(a);

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

}

}

结果截图：

6.binarySearch()

对排序好的数组，采用二分查找的方式查找某个元素，可以在整个数组中查找，也可以在某个范围内查找。

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraysTest02

{

public static void main(String[] args)

{

int[] a = {1,45,78,23,123,98,67,12,90,56};

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

Arrays.sort(a);

System.out.println("-----------排序后数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("在整个数组中寻找：");

System.out.println(Arrays.binarySearch(a,78));

System.out.print("在局部范围内寻找：");

System.out.println(Arrays.binarySearch(a,4,7,1));

}

}

结果截图：

更多关于java相关内容感兴趣的读者可查看本站专题：《Java数组操作技巧总结》、《Java字符与字符串操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》

希望本文所述对大家java程序设计有所帮助。

{

System.out.print(a[i]+",");

}

System.out.print("\n");

}

}

结果截图：

6.binarySearch()

对排序好的数组，采用二分查找的方式查找某个元素，可以在整个数组中查找，也可以在某个范围内查找。

以int数组来分析，其他类型的数组原理一样

练习源码：

import java.util.Arrays;

public class ArraysTest02

{

public static void main(String[] args)

{

int[] a = {1,45,78,23,123,98,67,12,90,56};

System.out.println("-----------原始数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

Arrays.sort(a);

System.out.println("-----------排序后数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("在整个数组中寻找：");

System.out.println(Arrays.binarySearch(a,78));

System.out.print("在局部范围内寻找：");

System.out.println(Arrays.binarySearch(a,4,7,1));

}

}

结果截图：

更多关于java相关内容感兴趣的读者可查看本站专题：《Java数组操作技巧总结》、《Java字符与字符串操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》

希望本文所述对大家java程序设计有所帮助。

{

System.out.print(a[i]+",");

}

System.out.print("\n");

Arrays.sort(a);

System.out.println("-----------排序后数组---------");

for(int i = 0;i

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("在整个数组中寻找：");

System.out.println(Arrays.binarySearch(a,78));

System.out.print("在局部范围内寻找：");

System.out.println(Arrays.binarySearch(a,4,7,1));

}

}

结果截图：

更多关于java相关内容感兴趣的读者可查看本站专题：《Java数组操作技巧总结》、《Java字符与字符串操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》

希望本文所述对大家java程序设计有所帮助。

{

System.out.print(a[i]+",");

}

System.out.print("\n");

System.out.print("在整个数组中寻找：");

System.out.println(Arrays.binarySearch(a,78));

System.out.print("在局部范围内寻找：");

System.out.println(Arrays.binarySearch(a,4,7,1));

}

}

结果截图：

更多关于java相关内容感兴趣的读者可查看本站专题：《Java数组操作技巧总结》、《Java字符与字符串操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》

希望本文所述对大家java程序设计有所帮助。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。