设计一个JAVA程序设计一个java程序有数组a()

转载

IT智行领袖 2023-07-28 14:07:27

文章标签 设计一个JAVA程序数组升序 java 文章分类 Java 后端开发

声明数组：

int[] a;

int a[];

两种方式。一般选择第一种，比较一目了然。

初始化,必须指定长度：

int[] a = new int[10];

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

初始化：

1. package com.zjf; 
2.  
3. import java.util.Arrays; 
4.  
5. import com.zjf.spring.mybatis.model.Person; 
6.  
7. public class Test { 
8.  
9. public static void main(String[] args) { 
10. //定义数组 
11. int[] a = new int[3]; 
12. //默认初始化 打印查看为0 
13.       System.out.println(Arrays.toString(a)); 
14. //也可以存储对象 
15. new Person[2]; 
16. //默认初始化为null 
17.       System.out.println(Arrays.toString(p)); 
18.  
19.     } 
20. }

结果：

[0, 0, 0]

[null, null]

数组拷贝

两种方式。
1. package com.zjf; 
2. import java.util.Arrays; 
3. public class Test { 
4. public static void main(String[] args) { 
5. int[] a = {0,1,2,3,4,5,6,7,8,9}; 
6. int[] b = Arrays.copyOf(a, a.length); 
7. int[] c = new int[a.length]; 
8.       System.arraycopy(a, 0, c, 0, a.length); 
9.       System.out.println(Arrays.toString(b)); 
10.       System.out.println(Arrays.toString(c)); 
11.     } 
12. }

结果：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

数组排序：

1. package com.zjf; 
2. import java.util.Arrays; 
3. import com.zjf.spring.mybatis.model.Person; 
4. public class Test { 
5. public static void main(String[] args) { 
6. int[] a = {0,6,2,8,4,5,1,7,3,9}; 
7.       Arrays.sort(a); 
8.       System.out.println(Arrays.toString(a)); 
9. new Person(2,"zjf",29,"beiing"); 
10. new Person(1,"xhj",29,"beiing"); 
11.       Person[] p = {p1,p2}; 
12.       Arrays.sort(p); 
13.       System.out.println(Arrays.toString(p)); 
14.     } 
15. } 
结果：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Exception in thread "main" java.lang.ClassCastException: com.zjf.spring.mybatis.model.Person cannot be cast to java.lang.Comparable

at java.util.ComparableTimSort.countRunAndMakeAscending(Unknown Source)

at java.util.ComparableTimSort.sort(Unknown Source)

at java.util.Arrays.sort(Unknown Source)

Test.java:13)

1. package com.zjf; 
2.  
3. import java.util.Arrays; 
4. import java.util.Comparator; 
5.  
6. import com.zjf.spring.mybatis.model.Person; 
7.  
8. public class Test { 
9. public static void main(String[] args) { 
10. int[] a = { 0, 6, 2, 8, 4, 5, 1, 7, 3, 9 }; 
11.       Arrays.sort(a); 
12.       System.out.println(Arrays.toString(a)); 
13. new Person(2, "zjf", 29, "beiing"); 
14. new Person(1, "xhj", 29, "beiing"); 
15.       Person[] p = { p1, p2 }; 
16. new Comparator<Person>() { 
17. public int compare(Person o1, Person o2) { 
18. return o1.getId().compareTo(o2.getId()); 
19.          } 
20.       }); 
21.       System.out.println(Arrays.toString(p)); 
22.    } 
23. }

结果：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[id:1,name:xhj, id:2,name:zjf]

注：Arrays.sort使用的是快速排序算法。

Arrays的API：

方法摘要
static	asList(T... a) 返回一个受指定数组支持的固定大小的列表。
static int	binarySearch(byte[] a, byte key) 使用二分搜索算法来搜索指定的 byte 型数组，以获得指定的值。
static int	binarySearch(char[] a, char key) 使用二分搜索算法来搜索指定的 char 型数组，以获得指定的值。
static int	binarySearch(double[] a, double key) 使用二分搜索算法来搜索指定的 double 型数组，以获得指定的值。
static int	binarySearch(float[] a, float key) 使用二分搜索算法来搜索指定的 float 型数组，以获得指定的值。
static int	binarySearch(int[] a, int key) 使用二分搜索算法来搜索指定的 int 型数组，以获得指定的值。
static int	binarySearch(long[] a, long key) 使用二分搜索算法来搜索指定的 long 型数组，以获得指定的值。
static int	binarySearch(Object[] a, Object key) 使用二分搜索算法来搜索指定数组，以获得指定对象。
static int	binarySearch(short[] a, short key) 使用二分搜索算法来搜索指定的 short 型数组，以获得指定的值。
static	binarySearch(T[] a, T key, Comparator<? super T> c) 使用二分搜索算法来搜索指定数组，以获得指定对象。
static boolean	deepEquals(Object[] a1, Object[] a2) 如果两个指定数组彼此是深层相等的，则返回 true。
static int	deepHashCode(Object[] a) 基于指定数组的"深层内容"返回哈希码。
static String	deepToString(Object[] a) 返回指定数组"深层内容"的字符串表示形式。
static boolean	equals(boolean[] a, boolean[] a2) 如果两个指定的 boolean 型数组彼此相等，则返回 true。
static boolean	equals(byte[] a, byte[] a2) 如果两个指定的 byte 型数组彼此相等，则返回 true。
static boolean	equals(char[] a, char[] a2) 如果两个指定的 char 型数组彼此相等，则返回 true。
static boolean	equals(double[] a, double[] a2) 如果两个指定的 double 型数组彼此相等，则返回 true。
static boolean	equals(float[] a, float[] a2) 如果两个指定的 float 型数组彼此相等，则返回 true。
static boolean	equals(int[] a, int[] a2) 如果两个指定的 int 型数组彼此相等，则返回 true。
static boolean	equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。
static boolean	equals(Object[] a, Object[] a2) 如果两个指定的 Objects 数组彼此相等，则返回 true。
static boolean	equals(short[] a, short[] a2) 如果两个指定的 short 型数组彼此相等，则返回 true。
static void	fill(boolean[] a, boolean val) 将指定的 boolean 值分配给指定 boolean 型数组的每个元素。
static void	fill(boolean[] a, int fromIndex, int toIndex, boolean val) 将指定的 boolean 值分配给指定 boolean 型数组指定范围中的每个元素。
static void	fill(byte[] a, byte val) 将指定的 byte 值分配给指定 byte 节型数组的每个元素。
static void	fill(byte[] a, int fromIndex, int toIndex, byte val) 将指定的 byte 值分配给指定 byte 型数组指定范围中的每个元素。
static void	fill(char[] a, char val) 将指定的 char 值分配给指定 char 型数组的每个元素。
static void	fill(char[] a, int fromIndex, int toIndex, char val) 将指定的 char 值分配给指定 char 型数组指定范围中的每个元素。
static void	fill(double[] a, double val) 将指定的 double 值分配给指定 double 型数组的每个元素。
static void	fill(double[] a, int fromIndex, int toIndex, double val) 将指定的 double 值分配给指定 double 型数组指定范围中的每个元素。
static void	fill(float[] a, float val) 将指定的 float 值分配给指定 float 型数组的每个元素。
static void	fill(float[] a, int fromIndex, int toIndex, float val) 将指定的 float 值分配给指定 float 型数组指定范围中的每个元素。
static void	fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组的每个元素。
static void	fill(int[] a, int fromIndex, int toIndex, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。
static void	fill(long[] a, int fromIndex, int toIndex, long val) 将指定的 long 值分配给指定 long 型数组指定范围中的每个元素。
static void	fill(long[] a, long val) 将指定的 long 值分配给指定 long 型数组的每个元素。
static void	fill(Object[] a, int fromIndex, int toIndex, Object val) 将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
static void	fill(Object[] a, Object val) 将指定的 Object 引用分配给指定 Object 数组的每个元素。
static void	fill(short[] a, int fromIndex, int toIndex, short val) 将指定的 short 值分配给指定 short 型数组指定范围中的每个元素。
static void	fill(short[] a, short val) 将指定的 short 值分配给指定 short 型数组的每个元素。
static int	hashCode(boolean[] a) 基于指定数组的内容返回哈希码。
static int	hashCode(byte[] a) 基于指定数组的内容返回哈希码。
static int	hashCode(char[] a) 基于指定数组的内容返回哈希码。
static int	hashCode(double[] a) 基于指定数组的内容返回哈希码。
static int	hashCode(float[] a) 基于指定数组的内容返回哈希码。
static int	hashCode(int[] a) 基于指定数组的内容返回哈希码。
static int	hashCode(long[] a) 基于指定数组的内容返回哈希码。
static int	hashCode(Object[] a) 基于指定数组的内容返回哈希码。
static int	hashCode(short[] a) 基于指定数组的内容返回哈希码。
static void	sort(byte[] a) 对指定的 byte 型数组按数字升序进行排序。
static void	sort(byte[] a, int fromIndex, int toIndex) 对指定 byte 型数组的指定范围按数字升序进行排序。
static void	sort(char[] a) 对指定的 char 型数组按数字升序进行排序。
static void	sort(char[] a, int fromIndex, int toIndex) 对指定 char 型数组的指定范围按数字升序进行排序。
static void	sort(double[] a) 对指定的 double 型数组按数字升序进行排序。
static void	sort(double[] a, int fromIndex, int toIndex) 对指定 double 型数组的指定范围按数字升序进行排序。
static void	sort(float[] a) 对指定的 float 型数组按数字升序进行排序。
static void	sort(float[] a, int fromIndex, int toIndex) 对指定 float 型数组的指定范围按数字升序进行排序。
static void	sort(int[] a) 对指定的 int 型数组按数字升序进行排序。
static void	sort(int[] a, int fromIndex, int toIndex) 对指定 int 型数组的指定范围按数字升序进行排序。
static void	sort(long[] a) 对指定的 long 型数组按数字升序进行排序。
static void	sort(long[] a, int fromIndex, int toIndex) 对指定 long 型数组的指定范围按数字升序进行排序。
static void	sort(Object[] a) 根据元素的自然顺序，对指定对象数组按升序进行排序。
static void	sort(Object[] a, int fromIndex, int toIndex) 根据元素的自然顺序，对指定对象数组的指定范围按升序进行排序。
static void	sort(short[] a) 对指定的 short 型数组按数字升序进行排序。
static void	sort(short[] a, int fromIndex, int toIndex) 对指定 short 型数组的指定范围按数字升序进行排序。
static	sort(T[] a, Comparator<? super T> c) 根据指定比较器产生的顺序对指定对象数组进行排序。
static	sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c) 根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。
static String	toString(boolean[] a) 返回指定数组内容的字符串表示形式。
static String	toString(byte[] a) 返回指定数组内容的字符串表示形式。
static String	toString(char[] a) 返回指定数组内容的字符串表示形式。
static String	toString(double[] a) 返回指定数组内容的字符串表示形式。
static String	toString(float[] a) 返回指定数组内容的字符串表示形式。
static String	toString(int[] a) 返回指定数组内容的字符串表示形式。
static String	toString(long[] a) 返回指定数组内容的字符串表示形式。
static String	toString(Object[] a) 返回指定数组内容的字符串表示形式。
static String	toString(short[] a) 返回指定数组内容的字符串表示形式。