java-自定义数组的工具类

杨利霞

java-jajava-自定义数组的工具类va-自定义数组的工具类自定义数组jjava-自定义数组的工具类ava-自定义数组的工具类

, H# I+ x2 f6 u+ M1 Y6 P' L6 gjava-自定义数组的工具类
4 o* }$ z) s8 {& H, N/ u$ ?
1 R; s% i# ~& ^: z" a2 x; P文章目录
# x2 f% M5 l6 p# [1 fjava-自定义数组的工具类
. a9 [  i$ W9 l$ D第一步：封装方法到B.java
/ s5 a- t/ G' p5 s, j' b8 n第二步：在BCeShi.java中测试
运行结果（对应上面main方法中的代码注释来看）：
java-自定义数组的工具类
) q0 n$ g" Z' [Java—数组中涉及的常见算法有写到

/ H+ D9 s4 [( o9 k$ _: y求数值型数组中元素的最大值、最小值、平均数、总和等
: h& [( c# }# U0 t9 d数组的复制、反转、查找(线性查找、二分法查找)等等
数组元素的排序算法等等
" ]) z8 K7 J8 O+ [这样的功能都可以封装到一个个方法当中

ps：这里和Java—数组中涉及的常见算法相比也相当于把之前分开写的比较冗杂的数组涉及的常用算法归类总结到了一起
# i) e9 x7 t- ]# ?  E
第一步：封装方法到B.java
2 ]2 M' s5 y- l8 G0 ~, V+ |+ Z: Spackage dierjieduan;
: E: y( j2 w8 E( F2 b//自定义数组的工具类
% }) O6 L5 [' h( T9 `6 Y7 A1 D% j# p5 W/ Ipublic class B {

    //求数组的最大值
    public int getMax(int[] arr){
        int max=arr[0];
        for (int i = 0; i <arr.length ; i++) {
! S* ^$ Y; g2 A" Q# {            if (arr>max){
6 A2 Z3 |- n# ]) [# v' K8 P                max=arr;
) N, t( ~% b1 p: ^! @            }
        }
        return max;
    }

    //求数组的最小值
    public int getMin(int[] arr){
# v( ~; Z7 ~: m+ {( J% V) R1 R& f        int min=arr[0];
! T" J: Z6 M! d( A        for (int i = 0; i <arr.length ; i++) {
            if (arr<min){
                min=arr;
5 @, P; t7 n6 w$ W) Z" U' Y4 n/ e            }
! R) X5 ]6 K/ y% B9 B& S        }
! @' Q" j) \' a0 H/ y8 q  f! ?        return min;
    }
9 X) K& x0 V2 w; `- _- n# S
    //求数组的总和
4 Z: E$ L- w( L9 O7 X    public int getSum(int[] arr){
) |' p8 }1 V9 A" x7 \" O& f0 [4 A        int sum=0;
        for (int i = 0; i <arr.length ; i++) {
6 N( D4 [7 n6 ?, v5 l            sum=sum+arr;
        }
        return sum;
& J1 ?/ E+ ]( G: b* @( {2 _    }
* a  A: j* }) F* ^& W
# U; x1 e  e* E4 I5 K! S5 z    //求数组的平均值
    public double getAvg(int[] arr){

        return getSum(arr)/arr.length;//注意返回值的灵活运用
; ~# J3 }; M; I$ a7 I+ v3 e    }
+ ~6 _: e3 l6 I: `1 N! `8 X
* W* @7 q* G4 g1 C- Q2 ]8 `    //反转数组
    public void reverse(int[] arr){
, v) j- z3 P& I, c0 ]        for (int i = 0; i <arr.length/2; i++) {
            int temp =arr;
0 D: a9 r, h0 y$ Q; s            arr=arr[arr.length-i-1];
" H" n) V3 M, S' X; Q            arr[arr.length-i-1]=temp;
        }
* Z) Y8 ~8 m8 T* _3 p    }

5 [( r: q) q3 A! P  z" q, `6 |) S& m0 \    //复制数组
    public int[] copy(int[] arr){
        int[] arr1=new int[arr.length];
0 ^: D1 {2 ^/ s" w+ b        for (int i = 0; i <arr.length ; i++) {
8 P; q$ p  P2 n) g7 Y            arr1=arr;
        }
        return arr1;
    }
7 I" v6 \% Y* [! K
. ?9 n2 o6 e* z' E. G2 N- c2 j    //数组排序(冒泡)
# o' }1 F% h/ m; E# M, D6 w$ j, Y    public void sort(int[] arr){
        for (int i = 0; i <arr.length ; i++) {
7 ~9 V' ^/ f; o! z! p) [( w) X            for (int j = 0; j <arr.length-1-i ; j++) {
                if (arr[j]>arr[j+1]){
) t+ i1 m! q; B; s. ]- J9 s+ a                    int temp=arr[j];
. v8 r8 }) w3 L3 a                    arr[j]=arr[j+1];
; M- a, n1 R+ s( W% ~& X: D                    arr[j+1]=temp;
( n# T9 e' a  t! _1 `; U                }
            }
  J/ j& }. M5 l3 y3 ?6 `$ X# a; i4 n        }
    }
! x- z9 [: M' ^) S- y1 P+ s" w1 l
% P8 v- s8 z1 g3 C  y( X. E- l    //遍历数组
6 v* m9 L" W/ }" `; \    public void print(int[] arr){
        for (int i = 0; i <arr.length ; i++) {
            System.out.print(arr+"\t");
        }
' ^1 j" v: D) T: D3 N* F- ?        System.out.println();//遍历后换行
    }
9 p; |; R* P/ R" @( o
    //查找指定元素
8 [% e1 r2 {" y! a/ @+ n    public int getIndex(int[] arr,int dest){//两个参数（某个数组找某个元素）
        for (int i = 0; i <arr.length ; i++) {
3 s9 ~2 h; o' Z$ a/ e            if (arr==dest){
                return i;
            }
        }
* M" A6 E4 T7 J8 K- y: R        return -1;//返回1个负数表示没找到
" C+ d6 I3 p9 v# |; f# S1 d" w$ K$ {    }
1 ]; r5 A) j  v4 c' s. M2 K}

1
2
/ T/ }2 X7 \7 A+ H& W. r. ?+ U  W3
, |' W7 Q: B. \; }  t4
5
. H5 u( @. e2 |7 }4 \3 x5 ]6
7
$ R$ m- M3 I" H; C8
9
, H) ^( p5 j$ ^+ a10
4 Y. ^! V: T: U: j11
/ \2 Q. }  w! I9 A' ^, U% @! D12
, U6 R! ]- Y; F  l13
8 R: p4 z  J( u  ~5 |7 D14
1 `) c! q' ]' d' q# L" p* P& q15
0 ~" x( d3 V* L5 J16
' }& ?1 s( q& O$ ]17
5 x4 E& }9 j6 ]0 A8 q6 c18
19
20
21
22
, U: I/ l# }  p- X23
" Z( g8 e: y. w$ u3 n4 q24
25
26
27
28
29
$ d) [! y, P/ N30
31
32
8 j: b9 C! c9 S. {33
5 H  F0 n3 p9 K- {- b/ j" q34
5 }- }4 Z# K& Q3 a% _35
36
37
! s9 Q2 m  ]- l) [/ [- S38
+ q0 n8 G. E2 v/ l" P% Q39
  t2 k( b; m& e" b40
6 V+ [; f; o7 b2 h5 V6 X. r41
3 }5 C& k: n2 r2 B4 B1 S" Y42
43
44
$ Z+ [8 [& P3 [45
46
47
48
5 y6 K0 v$ W0 A5 l6 I' E# ]5 `49
50
/ j+ T8 Y* p7 [! x- h51
4 W0 G* ]- \2 T+ R) ?52
- x" h, r* x. V53
# B8 j( ^$ d, b1 x9 I4 g' U( I+ g54
55
+ Q# S# F. h' |+ _. A/ E56
' H# F( e! w, Y8 o  F- Y: A57
* }6 J! _: ]5 J6 W1 O- a58
; P, @' W& w  E* E; ~" Q59
60
61
" P- ?! r2 U5 X62
63
64
65
  l& T' ?; W. X! ^. k66
67
1 L: _, {' ~* p$ L: j  a: q68
$ g* h5 G1 D% W8 u3 ?69
70
71
72
73
& d5 s4 H; N/ E9 q74
75
76
77
0 R2 W5 c1 l- c  L78
. q" R- k  U% Q, ]) r! E79
80
81
/ I" v4 g" {) T" c- j3 J82
83
& }2 j3 T6 d4 R6 \7 U7 u84
) U5 Y6 g/ V4 [2 L8 b85
86
87
88
89
90
第二步：在BCeShi.java中测试
8 G6 w/ _3 t, p% Q3 X# Xps：这里两个都在一个包中，如果不在一个包就要导包
9 d, o/ m3 n7 A$ \  k7 Y9 @
  K$ U+ k( \" [& T9 t5 ?package dierjieduan;
public class BCeShi {
/ I; _) Z5 [1 ^    public static void main(String[] args) {
& h" w' ?4 n- y/ W3 \9 j        B p = new B();//建一个B的对象
        int[] arr= new int[]{12,34,55,423,5567,123456,1,4,5};//新new一个数组
        //求最值、总和、平均值
  J) z7 Q3 Y9 W( J8 P        int max=p.getMax(arr);//最大值
0 l* R3 B% _( o5 i/ b' y" h) B        int min=p.getMin(arr);//最小值
        int sum=p.getSum(arr);//总和
        double avg=p.getAvg(arr);//平均数
        System.out.println("最大值:"+max+"最小值为:"+min+"总和为:"+sum+"平均数为:"+avg);//输出
        p.print(arr);//反转前遍历（第一行）
: c. k$ N" D' E! w1 q$ [        p.reverse(arr);//反转数组
8 Z! ?3 B( T+ q8 ~        p.print(arr);//反转后遍历（第二行）
        int[] copyarr=p.copy(arr);//复制数组arr给新数组copyarr
        p.print(copyarr);//遍历copyarr(第三行)
* z6 M9 _; e7 t) f5 c# F5 Z8 q        p.print(arr);//排序前遍历（第四行）
        p.sort(arr);//排序（冒泡）
: P. y8 x% x" F8 G        p.print(arr);//排序后遍历（第五行）
% Y  w2 [) L8 m1 |        System.out.print("查找元素34：");//查找指定元素（这里针对的是排序后遍历出的数组，而不是最初的数组）
        int index= p.getIndex(arr,34);
        if (index>=0){
& u! N- s4 [$ ^! n/ u2 w            System.out.println("找到了，在位置："+index);
        }else {
; k0 P8 Y1 `, L' r$ D+ z: W            System.out.println("没有找到");
$ m2 X2 V3 C$ X9 g        }
    }
}

1
2
7 k) v* G" R6 S3
/ K; S5 j% d; ^. G7 \0 X+ [- G4
5
: e" |, n# [0 ?$ O: m4 ~6
  ^( }; p" p( M' T4 v5 s+ ?8 j, o6 U7
8
9
& b( W! E' B- j  g10
5 j- u, X9 |7 D4 n- P# l- K3 h/ e, h  g11
! l# z0 r- x& w5 X2 A6 a8 `. Q  ?12
- l* ^, V) q0 ]' c' u13
" D0 t# W& U- Z7 z14
5 v) d: b* s+ ~+ V( O  ?$ a15
/ B$ w& M7 w. g! H# M) V6 v: L; y: v* @; s16
17
18
# w* B1 L: j# Z$ i/ D  V( S2 S, y19
20
) O* U( `' t; k' w21
/ ]( v" Q2 y4 z: E22
# {4 y- b6 a6 S/ {* b% q23
4 j, d1 w+ O9 l8 B, S+ x24
25
26
: w2 p# v/ m* g4 C, A5 j27
0 T+ s5 z' d, G28
运行结果（对应上面main方法中的代码注释来看）：

————————————————
- `+ x) r, j( C$ U, _版权声明：本文为CSDN博主「金士曼」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_45869823/article/details/126754797


( w: }# a  L, e, Y2 a: E) {4 o

1051373629

感谢楼主的资料
( }, t0 i  e5 g7 Y; I- x& R