java-自定义数组的工具类

杨利霞

java-jajava-自定义数组的工具类va-自定义数组的工具类自定义数组jjava-自定义数组的工具类ava-自定义数组的工具类
" r) ?+ Y/ F: e7 r1 ?8 c
4 e" c: G; `. l1 `java-自定义数组的工具类

文章目录
, ~8 s, A" B% Pjava-自定义数组的工具类
& u, U( x; U" U, x, T" |! y第一步：封装方法到B.java
3 o& J; {" p1 O% ]! R- H3 {& i/ @第二步：在BCeShi.java中测试
# y+ g3 b6 S7 t0 y/ U% u3 j运行结果（对应上面main方法中的代码注释来看）：
java-自定义数组的工具类
Java—数组中涉及的常见算法有写到
- B: \6 a1 `; W; _  s/ a1 f
求数值型数组中元素的最大值、最小值、平均数、总和等
数组的复制、反转、查找(线性查找、二分法查找)等等
数组元素的排序算法等等
这样的功能都可以封装到一个个方法当中

ps：这里和Java—数组中涉及的常见算法相比也相当于把之前分开写的比较冗杂的数组涉及的常用算法归类总结到了一起

6 G8 _& G; @2 `第一步：封装方法到B.java
! p$ q: f6 @0 q6 w% a% Jpackage dierjieduan;
, \( [' x5 x3 R5 [5 X: r//自定义数组的工具类
public class B {

    //求数组的最大值
    public int getMax(int[] arr){
        int max=arr[0];
        for (int i = 0; i <arr.length ; i++) {
. e: Y$ `# N) X3 N* m            if (arr>max){
4 ?3 G" q. A! H( Q( W                max=arr;
7 t0 c) T' T% e5 q) L            }
        }
9 _3 f$ w& `; h. N2 E. }; F        return max;
1 M' y0 i/ G* O, {% ^    }
' S+ J9 L; ]# ~3 s
( D2 }7 K5 e' H9 h; m    //求数组的最小值
- g2 `0 t% {; @- }2 U    public int getMin(int[] arr){
        int min=arr[0];
5 n4 t7 I. D# G# Z2 i$ X9 R6 X        for (int i = 0; i <arr.length ; i++) {
            if (arr<min){
; F6 F; ^/ h9 P, X0 C$ H- w                min=arr;
: d! e" Z5 R8 d* q            }
        }
8 e/ Y7 i) k7 c* w        return min;
    }

    //求数组的总和
! g! q: a5 N5 g* q* D5 U    public int getSum(int[] arr){
* ^# G7 q. s8 f) o5 P: N. ?        int sum=0;
        for (int i = 0; i <arr.length ; i++) {
  q! w' ?- E% i" G3 |& ~3 F            sum=sum+arr;
        }
* P( R+ i+ l' m+ K        return sum;
2 S) r: m+ f! V  X9 O    }
# d- F2 \+ q& R" y, Y
    //求数组的平均值
1 W6 f' D9 U1 g0 S5 u    public double getAvg(int[] arr){
4 G/ A+ ~; p/ h1 k5 G/ q5 A
        return getSum(arr)/arr.length;//注意返回值的灵活运用
    }
! Y. p' K/ j* E! ~; o
$ p' b7 g) K- L0 t    //反转数组
, _- t! F; A2 f- `" T; T, V    public void reverse(int[] arr){
) Z# U5 V1 x& Y/ r        for (int i = 0; i <arr.length/2; i++) {
9 K' `2 k% Y; b            int temp =arr;
) O* r3 @" V1 @. n9 X0 G            arr=arr[arr.length-i-1];
            arr[arr.length-i-1]=temp;
        }
1 I) w7 y, |7 v    }

    //复制数组
    public int[] copy(int[] arr){
        int[] arr1=new int[arr.length];
        for (int i = 0; i <arr.length ; i++) {
* @. J6 l$ z/ f" R            arr1=arr;
        }
        return arr1;
    }

    //数组排序(冒泡)
( ]+ |2 V) W: G1 [1 r    public void sort(int[] arr){
  l8 J3 E% ^- b2 z  X        for (int i = 0; i <arr.length ; i++) {
            for (int j = 0; j <arr.length-1-i ; j++) {
' G% ?0 {6 W/ j                if (arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
7 n- g/ @5 R2 z- u7 d                }
/ T, ]- r: w7 |4 E            }
( s+ r% c  i# n; J) A& e        }
8 E3 G$ J3 a0 P, F' Z    }
" l  m- Y0 I+ G# r9 q
    //遍历数组
    public void print(int[] arr){
6 Y5 B6 h6 ?2 V. _2 k, O+ V        for (int i = 0; i <arr.length ; i++) {
) e+ `% I# Q0 H. I3 J: Y            System.out.print(arr+"\t");
; x; b$ R* o( Z7 @4 P' Q        }
1 \; T+ U* B( ^        System.out.println();//遍历后换行
2 c; `/ a/ g) }! d, E- a1 `6 R$ j    }
& h5 {- p. K, D
% s; @" B/ B8 Y    //查找指定元素
2 ~; q) {* T. r2 E1 Y7 J    public int getIndex(int[] arr,int dest){//两个参数（某个数组找某个元素）
        for (int i = 0; i <arr.length ; i++) {
            if (arr==dest){
                return i;
            }
+ a0 F" u" O! [$ L* U3 t( j        }
        return -1;//返回1个负数表示没找到
  g+ \6 E* r$ m0 \' |    }
+ X. D- V+ T+ i: u+ w+ a}

) `# T4 K3 i7 {: l: M9 P1
2
. X9 D& `  D5 k$ Y/ h7 |3
2 o& W" `: k% k4
5
, ?6 m/ b% q2 e2 B7 a6
7
8
9
10
11
- L& k" ^6 |: m* b4 [' x12
5 ]4 g& h4 l* J5 K/ D4 v13
& m0 `5 O0 \/ G. O- L) I+ r14
15
16
17
# F0 Y  K) s% L# ]# L18
19
20
) _8 h" A, V9 Z# j: R$ ^/ c21
22
23
7 t1 [7 x7 V+ A3 h1 {# M24
25
5 }, S" s! @2 Z/ {" o7 p  F26
27
28
- @; b3 C4 \* A5 i) ^29
: g0 E7 F, k( N8 ?2 D# G+ c8 k2 g30
31
32
33
3 Q8 [2 m( l+ S- I$ O" X+ A0 D34
2 R8 G& I" q. ]; G35
36
$ R5 n8 j& X4 }/ g! o+ H! x3 l37
38
$ S' q  K4 _; I3 `( {0 P. r39
40
41
42
43
44
45
46
47
* n' d4 i+ F9 G8 q' C- b. p48
$ p' j# }' W. `2 h& |% X2 s49
: b# H! m3 E, z1 h! E$ ^4 \50
51
& k3 Z$ c" g3 I9 X- c0 u52
53
54
55
56
57
58
59
60
61
( K: I9 t; `* b2 c2 `9 K) L' i5 R62
5 Q! |8 W; E! R; ]7 F; I5 |63
- ?' C+ v; W* Y& F7 m9 Q/ C9 `64
; g) _- Q  A8 ]# L$ q65
66
$ F* A* m5 {: N! c67
68
* ~, q. d% d! F  k8 Y; P69
70
( O9 C" l/ d% G' h7 }9 ~5 }* {% t71
72
& ?# {/ N. k- [) K1 n% p* }$ c73
( y* E9 A8 L8 ^! r74
75
% Z" u2 E& x7 J76
77
* s2 K5 i/ ~9 c: Y1 q78
79
80
. r0 a6 }' E# X81
& r' h3 @9 x7 t, `% r& M82
83
2 H7 H& f2 M- `' Q0 d# X& d) m84
- T% `0 F) q# e" N0 Q8 }" i85
' {/ Y7 z6 ?$ f. }, {5 j7 m+ J86
) E0 j: W- B2 e! S: {87
88
! B- E9 k* n( F( x89
9 P  h% c8 o' {$ N90
; h! T$ o6 M5 }) P4 \' y( B: w1 m第二步：在BCeShi.java中测试
ps：这里两个都在一个包中，如果不在一个包就要导包

package dierjieduan;
4 R, \  U0 [/ ?: O0 t) S4 Xpublic class BCeShi {
$ v5 h9 l5 Z8 f( ^2 J+ j0 \; V: Y    public static void main(String[] args) {
: G8 Q- w( ?3 J% h$ @! I" G: I        B p = new B();//建一个B的对象
* o" G( `% h) E        int[] arr= new int[]{12,34,55,423,5567,123456,1,4,5};//新new一个数组
        //求最值、总和、平均值
        int max=p.getMax(arr);//最大值
        int min=p.getMin(arr);//最小值
% F1 o* U+ g% t) Y! ?% S        int sum=p.getSum(arr);//总和
: }  \. d/ J) L% @; W! c        double avg=p.getAvg(arr);//平均数
7 C9 i9 r5 m( k, N  ^        System.out.println("最大值:"+max+"最小值为:"+min+"总和为:"+sum+"平均数为:"+avg);//输出
. y) B2 d/ Y* Y        p.print(arr);//反转前遍历（第一行）
        p.reverse(arr);//反转数组
        p.print(arr);//反转后遍历（第二行）
, k4 d) b/ T" a        int[] copyarr=p.copy(arr);//复制数组arr给新数组copyarr
: h0 I$ ?9 c* N7 a9 J        p.print(copyarr);//遍历copyarr(第三行)
" t; M. f( G4 y" j0 o4 f3 c% A        p.print(arr);//排序前遍历（第四行）
) N$ M8 U' h$ }9 r/ ~& f' K$ I        p.sort(arr);//排序（冒泡）
1 K5 g: V: s) V& }, g- e        p.print(arr);//排序后遍历（第五行）
" I% W/ x6 T: Q        System.out.print("查找元素34：");//查找指定元素（这里针对的是排序后遍历出的数组，而不是最初的数组）
        int index= p.getIndex(arr,34);
) g. ^9 D0 [( l9 m) T        if (index>=0){
5 _7 f* p7 x: ^* ]+ a9 l" m            System.out.println("找到了，在位置："+index);
# K# D8 a+ `0 f, C0 i        }else {
            System.out.println("没有找到");
        }
& w- p2 x8 \2 Q5 J: R    }
}
* Q9 d4 b2 I! R2 V0 B
1
2 l9 a( l+ K  ]. y" x2
3
" \' @7 x" X  E/ _, R* ~7 ?, K4
3 R9 d( c% M1 Y: H% W5
6
& E6 C" N/ L! k7
8
% G0 Z: N5 G* B4 p) ?! y. m9
10
11
12
6 M# F, v# p7 [" l1 J13
14
15
16
  ^0 r" @; w, m7 }, y& H) {4 p17
18
2 \3 \/ R; H: f0 M+ H$ _1 _19
20
21
' l5 a, k8 [! B1 t1 S22
( F+ J+ q6 V2 ]5 x23
24
$ B( f; E8 u7 A( f25
26
, M* g+ |3 D2 v$ G7 `1 ?27
8 R. i8 w. _- l( P28
运行结果（对应上面main方法中的代码注释来看）：
; ?/ i0 q5 p! `) X( f0 x
————————————————
" E9 n* c+ f6 U* B. I3 J4 h5 U版权声明：本文为CSDN博主「金士曼」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
) g" a  Z% p; E$ j$ i) W5 k原文链接：https://blog.csdn.net/weixin_45869823/article/details/126754797

# r# ?8 V% g* \
5 b+ x& o( G1 e0 [7 J

1051373629

感谢楼主的资料
" [# h7 H( H; v. v