java-自定义数组的工具类

杨利霞

java-jajava-自定义数组的工具类va-自定义数组的工具类自定义数组jjava-自定义数组的工具类ava-自定义数组的工具类
% A$ r2 F7 q" U" p2 I% M
java-自定义数组的工具类

文章目录
; b: B4 F5 x/ {" Y3 N3 \java-自定义数组的工具类
$ h  g* V- K: M2 W' l7 [第一步：封装方法到B.java
第二步：在BCeShi.java中测试
运行结果（对应上面main方法中的代码注释来看）：
0 P$ C' K, D+ S) w1 ]6 p5 wjava-自定义数组的工具类
Java—数组中涉及的常见算法有写到

求数值型数组中元素的最大值、最小值、平均数、总和等
数组的复制、反转、查找(线性查找、二分法查找)等等
  Y/ {7 Z9 ^/ o( {数组元素的排序算法等等
这样的功能都可以封装到一个个方法当中
' X* C4 j5 i& z5 R' O) W
" c, g0 K3 k6 c/ Q: s) Eps：这里和Java—数组中涉及的常见算法相比也相当于把之前分开写的比较冗杂的数组涉及的常用算法归类总结到了一起

! z% y8 Z/ X( v5 V' k: {第一步：封装方法到B.java
* {5 m) \# X$ s1 f* C! wpackage dierjieduan;
( U" Q( c" H( c5 \0 _1 p4 P5 x//自定义数组的工具类
public class B {

    //求数组的最大值
    public int getMax(int[] arr){
        int max=arr[0];
4 ~* P/ B) s1 D  `: q  T        for (int i = 0; i <arr.length ; i++) {
            if (arr>max){
3 k! x7 z6 t+ q9 H9 u" `                max=arr;
7 W1 u& H, ^) n. z" q* A  X& a            }
4 L( x1 z. _  ^- |8 d# g4 h        }
        return max;
    }

6 u# ^) {8 y8 |( o    //求数组的最小值
, N4 I+ h: C5 M3 U    public int getMin(int[] arr){
& o9 j0 s3 E3 f; j        int min=arr[0];
- H! ^: E, I5 L! V- W/ f        for (int i = 0; i <arr.length ; i++) {
- X3 k# U6 j1 P+ d( J) ^            if (arr<min){
$ X: P: `$ l8 w; n$ n7 Q" l% k                min=arr;
            }
$ ?" a+ q& m6 g8 b        }
* B8 N, Y6 V/ V1 v        return min;
* }- ^+ |* O7 i$ \    }

+ }+ x2 v! U5 y- ~: E    //求数组的总和
    public int getSum(int[] arr){
% F: {* }3 |5 _# J        int sum=0;
        for (int i = 0; i <arr.length ; i++) {
            sum=sum+arr;
: l2 x. Q. Z- z' j9 Y9 M        }
# Z7 o( S3 p4 q: t. L- N( u# I" [        return sum;
+ V* D) H, p! b% H    }
+ |# U" I; L3 U# L5 I& u$ `% v
, q0 d0 ]0 L  m+ {: G+ m    //求数组的平均值
7 i3 |# Y- X. D4 L. A    public double getAvg(int[] arr){

1 |" P5 d: ~$ D/ e3 @0 o+ ^; }        return getSum(arr)/arr.length;//注意返回值的灵活运用
    }
% e# u6 ^8 d1 R; ^6 V. T2 w% e
2 Y$ J( H( u- I0 o# d    //反转数组
    public void reverse(int[] arr){
  `4 R' i+ ?# U  A, t1 q6 T        for (int i = 0; i <arr.length/2; i++) {
1 U. Z& o. [7 J$ @) A            int temp =arr;
            arr=arr[arr.length-i-1];
            arr[arr.length-i-1]=temp;
# P0 b$ T/ Q9 ]. w! X- F& M        }
0 Q+ H9 u7 p* W3 \+ a$ m    }
: J/ @. `: A3 ?( `, {
# R+ d( k7 t8 q0 {! y    //复制数组
    public int[] copy(int[] arr){
        int[] arr1=new int[arr.length];
& g0 F- h3 `4 n7 P* a7 S        for (int i = 0; i <arr.length ; i++) {
            arr1=arr;
( [  W$ B7 V; [& z% r6 ~( Y+ }        }
7 D0 x0 [' N' K3 `/ R4 V        return arr1;
    }
  C/ o! k! M$ x9 p* f
% H; q2 [& Q: b    //数组排序(冒泡)
    public void sort(int[] arr){
        for (int i = 0; i <arr.length ; i++) {
            for (int j = 0; j <arr.length-1-i ; j++) {
6 s5 `  o! C5 Q0 K1 w& [7 T                if (arr[j]>arr[j+1]){
                    int temp=arr[j];
$ ?- N- |0 H4 s& n" l) @                    arr[j]=arr[j+1];
, L3 }5 h$ x6 y/ q6 S  C  w                    arr[j+1]=temp;
# ], J/ ?. [# N) g$ i                }
9 M+ I; r& F* c+ p7 \4 m            }
        }
- r2 O: Q* D% T3 u' y    }
: V& P& P* z$ l' a) C
    //遍历数组
    public void print(int[] arr){
        for (int i = 0; i <arr.length ; i++) {
            System.out.print(arr+"\t");
        }
; \% E/ |! t9 B' s: p8 q2 [6 N        System.out.println();//遍历后换行
: T- r7 T$ e8 \4 ^/ C7 `7 y2 ]    }
4 L  P- u& M( i2 E' ?/ d5 }- j
    //查找指定元素
    public int getIndex(int[] arr,int dest){//两个参数（某个数组找某个元素）
        for (int i = 0; i <arr.length ; i++) {
/ R% U3 q1 H  m6 w' }8 M3 y            if (arr==dest){
" Y8 o' {+ F* P$ c  c2 e% J                return i;
            }
3 b9 s* Q( K$ ]        }
% z0 y( I& C- ?4 o        return -1;//返回1个负数表示没找到
    }
. n$ R( L& P+ D}

# n  c) r6 o2 K1
2
3 d, P7 ]" @& T0 S3 d, m% d6 x3
4
+ d% s$ r) ^' i, |8 e8 Q5 e/ C5
6
( s8 X( k& m9 F& X; q5 }7
2 M  [* J* j* c4 T3 Y8 m' f8
9
) b5 `( V! U; s9 v5 _$ W10
11
12
  K5 e( {; Y: j13
14
15
16
( G" @' b, y& Z* ]% q17
18
% B; h* c, G$ k8 K2 v' s, V! B4 ?. E19
0 f. z; J/ n- l+ H$ w8 }" S4 c20
21
) S9 `7 q4 a  S/ v22
23
24
25
# {  i: z1 z; s* P+ {$ U7 h" v! T26
27
. b4 X$ b1 Q) l  p0 @' b28
29
8 U  z" a2 F" L% C30
31
% V8 X: W  b$ S, Q32
- [% o; x" c) h4 g% t1 ~; u. T33
34
35
36
37
38
39
: ~. @4 n% T+ s; K: D: g40
% U* R' K% g% U41
: T. K8 S+ ~" J$ d42
+ Y! }3 Y* B- I# z8 r43
+ u0 J' H6 X5 P7 w44
$ {5 [  s- E! V8 W9 i45
+ e( M; l3 k) V46
0 j0 @$ ?7 q0 G0 f5 ^47
48
8 `$ C: u; `; O) W49
50
51
52
53
$ B, a8 b' T4 c" }4 l6 I$ [9 n54
55
56
57
58
/ @! z9 y1 R; L* Q59
" m1 Y- q* L( W2 |8 I1 @60
& Q* @- u+ e$ v7 N5 d61
62
$ i1 q: {6 ]1 G0 J6 V3 v7 s1 ]63
64
" a5 f2 x& G/ y( ~# p# }$ U65
: e  C* y, k$ y$ k6 f3 D66
7 g# U' h# ?' p67
68
6 Y9 t0 y( X9 M. a& N5 [69
: p  w. y( r8 b# H( B4 ^70
71
72
: O( ?' c4 g# g73
! n( e& U7 i( Y5 T- j8 @74
75
  ~/ G% l# {& n76
77
8 n6 P; ]! E% `9 z9 Q0 P78
79
80
4 f; p: \2 F! B4 i1 H; l. g81
% p3 p% d1 \% c+ t- Z8 h82
# E6 z* H) _3 f4 e83
: K& Z% d* S$ c' U& W0 P0 O84
85
86
1 t2 K5 w, \  @7 D+ a87
88
3 |* L* W! Q1 Y, ]- W89
. S* _' d7 g$ Q' @: C$ D% `90
: x5 S9 Q& ]8 ^1 S- X$ U第二步：在BCeShi.java中测试
ps：这里两个都在一个包中，如果不在一个包就要导包

package dierjieduan;
/ ]( }4 a! x+ ^" a" R$ ^public class BCeShi {
# V% Q/ X' x* `    public static void main(String[] args) {
/ Q* ^! y5 {( V. v  {7 a0 q2 g& B        B p = new B();//建一个B的对象
        int[] arr= new int[]{12,34,55,423,5567,123456,1,4,5};//新new一个数组
9 r6 Z" L; y" z        //求最值、总和、平均值
        int max=p.getMax(arr);//最大值
        int min=p.getMin(arr);//最小值
: C! b, t# _  l" e& |9 {$ n( v        int sum=p.getSum(arr);//总和
2 D# S/ O( V; J5 S1 {* ^1 ]  y) v        double avg=p.getAvg(arr);//平均数
        System.out.println("最大值:"+max+"最小值为:"+min+"总和为:"+sum+"平均数为:"+avg);//输出
3 L/ d6 b$ Y3 W& x7 @9 ~        p.print(arr);//反转前遍历（第一行）
        p.reverse(arr);//反转数组
        p.print(arr);//反转后遍历（第二行）
        int[] copyarr=p.copy(arr);//复制数组arr给新数组copyarr
        p.print(copyarr);//遍历copyarr(第三行)
        p.print(arr);//排序前遍历（第四行）
        p.sort(arr);//排序（冒泡）
        p.print(arr);//排序后遍历（第五行）
5 |" S+ T) Q5 W% a, i2 E        System.out.print("查找元素34：");//查找指定元素（这里针对的是排序后遍历出的数组，而不是最初的数组）
: c4 O& E; R6 o" P9 Q        int index= p.getIndex(arr,34);
        if (index>=0){
            System.out.println("找到了，在位置："+index);
1 J& P3 @/ k* m        }else {
            System.out.println("没有找到");
        }
    }
( z& y! A& ]" }: w9 ]}

) ?  a  e" ^% S1
2
. r% R% G, a! G6 m3
4
) S% Y! x6 ^" L, V$ v/ z4 r5
6
7
8
4 i0 _% A  f  w5 B) V( S4 v9
5 d2 |7 O; K  B! P2 s10
11
' q2 f8 Q3 D/ U0 S* t: m) G( {12
2 b. B7 \$ {% v2 l$ z13
14
15
16
, `, a* a6 h8 z$ R17
' O' N2 P8 }- b1 h3 N18
19
7 R  g$ u: m1 S( p- [' s; t0 {20
/ ]# V3 A: \; N9 W5 p21
22
6 s* T; k& I1 T: c( S8 `- T23
( T( u# b. ^  ?4 n2 K24
25
26
' Y; d3 C5 y  Y27
2 `$ [+ v; g$ F8 Y28
- L  o5 q- }3 y2 m1 O运行结果（对应上面main方法中的代码注释来看）：
. b4 B7 m, M1 [- D. a7 ?  P- q
————————————————
. l! z6 O" k+ }. k1 _/ e2 c$ G版权声明：本文为CSDN博主「金士曼」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_45869823/article/details/126754797


1 X- v& J0 O/ U% h

1051373629

感谢楼主的资料
  Q! |% c5 O3 Q- i( u/ I