java-自定义数组的工具类

杨利霞

java-jajava-自定义数组的工具类va-自定义数组的工具类自定义数组jjava-自定义数组的工具类ava-自定义数组的工具类
) [7 Y' X" h* J7 w( G) Y* i
java-自定义数组的工具类
7 W  T7 ~0 X6 j, a) m
3 u) Q! W  @  L* D2 J文章目录
3 ]. P% P. V: @8 E- mjava-自定义数组的工具类
8 W( }, X- G0 o* ~7 [( k0 m第一步：封装方法到B.java
第二步：在BCeShi.java中测试
4 _4 ?8 v1 E4 Y! I+ h) U" l运行结果（对应上面main方法中的代码注释来看）：
java-自定义数组的工具类
Java—数组中涉及的常见算法有写到
5 o4 G/ V8 }& T% V% Q, I
求数值型数组中元素的最大值、最小值、平均数、总和等
& N' a! s4 }6 r. V( y! |数组的复制、反转、查找(线性查找、二分法查找)等等
% K4 c. ?* q- }8 {# U; C数组元素的排序算法等等
2 ]* h$ @. n7 M+ {& M+ K7 p, h; b3 C! F" e/ z这样的功能都可以封装到一个个方法当中
$ J  f  \: S8 B& l  d% f
. ]% Z8 i! g. l3 o, @$ O4 \6 O1 Lps：这里和Java—数组中涉及的常见算法相比也相当于把之前分开写的比较冗杂的数组涉及的常用算法归类总结到了一起
4 d% [/ L0 e0 y  L! R
第一步：封装方法到B.java
- N% j1 N* A/ W0 ~( {package dierjieduan;
//自定义数组的工具类
public class B {
/ P, f- h/ R% W7 O: V
    //求数组的最大值
    public int getMax(int[] arr){
. ?% g$ X+ d3 G9 }        int max=arr[0];
        for (int i = 0; i <arr.length ; i++) {
            if (arr>max){
5 ]$ [6 ?" \+ x- f: P6 k                max=arr;
- y( g/ s" S3 l- `            }
: ^  t7 Y4 l+ _5 k  B* g% N        }
        return max;
    }
* b, R2 v0 h& ?0 n7 J
4 ~4 T% @7 K3 o* q9 ?8 T    //求数组的最小值
    public int getMin(int[] arr){
        int min=arr[0];
. o% N& b$ l) l; z  y& |5 O) k2 u# A        for (int i = 0; i <arr.length ; i++) {
            if (arr<min){
                min=arr;
            }
        }
  \* k: Z1 e  c        return min;
    }

    //求数组的总和
- w; a; i$ J: `* p9 H    public int getSum(int[] arr){
        int sum=0;
        for (int i = 0; i <arr.length ; i++) {
- j1 P- I, Y- g0 Z$ l            sum=sum+arr;
        }
* A: z7 p7 N1 B% d; j% p        return sum;
. l! V4 @  s+ t& P( U; R3 R    }

. D$ H% i! H9 d    //求数组的平均值
4 P% ~, l& h) N& @    public double getAvg(int[] arr){
: b7 J& p, d/ e; H2 Z/ N! M
, L* C5 X  }# e+ ~" y4 X% N        return getSum(arr)/arr.length;//注意返回值的灵活运用
, f9 m! e1 r5 _+ h3 x    }

. Y/ M$ k) [- A: Z+ O4 f) W- Z    //反转数组
& L" I/ `1 |5 j' p" N    public void reverse(int[] arr){
        for (int i = 0; i <arr.length/2; i++) {
            int temp =arr;
            arr=arr[arr.length-i-1];
: K. o5 _& _; x4 S+ B            arr[arr.length-i-1]=temp;
- C9 {( U  W( E$ ?! r! H9 Z$ h        }
    }
7 j  u( @- S: V: B8 i# c
: U- c. ~% K+ B# }7 T0 G7 e, `0 r    //复制数组
& x6 }# r2 z3 b. H# r( `    public int[] copy(int[] arr){
        int[] arr1=new int[arr.length];
        for (int i = 0; i <arr.length ; i++) {
; S$ H5 {! F4 ?% K' a; o            arr1=arr;
        }
# j5 c! k/ e- Y- ?- [( s        return arr1;
    }

9 u6 Q/ M0 r" A: D/ Y    //数组排序(冒泡)
+ r1 }/ F6 |# J1 J! j9 ^    public void sort(int[] arr){
        for (int i = 0; i <arr.length ; i++) {
; I+ T+ b" r& e" N            for (int j = 0; j <arr.length-1-i ; j++) {
1 `, o5 K3 ~( c% N& e, J                if (arr[j]>arr[j+1]){
                    int temp=arr[j];
1 R0 J  g( ~3 e2 z7 T, }                    arr[j]=arr[j+1];
. n3 D9 N% Q/ y1 @                    arr[j+1]=temp;
8 D$ E1 L3 S0 a& o: X2 V- U; G" D# _                }
* N: {; v  T7 ?2 h            }
7 T/ p; n; E" [        }
    }

. ^/ u" v# @% _$ j" P    //遍历数组
    public void print(int[] arr){
9 A6 p7 F0 E8 `        for (int i = 0; i <arr.length ; i++) {
$ U+ d3 c3 {/ O: T- E            System.out.print(arr+"\t");
        }
6 u3 ~7 |9 c, k0 i' g% S! o; g0 o        System.out.println();//遍历后换行
3 g6 T) _/ c( [) w* U2 j    }

% M  g, U: x2 p( v    //查找指定元素
    public int getIndex(int[] arr,int dest){//两个参数（某个数组找某个元素）
        for (int i = 0; i <arr.length ; i++) {
            if (arr==dest){
                return i;
, J$ b2 a' b2 X            }
        }
% j! p! K3 h  P# k; m$ I" q& F        return -1;//返回1个负数表示没找到
    }
9 Z6 y% b, \: K# t9 ?# Z1 N% y" w" c}
' N, a% s% ^4 b1 y) T+ A7 P& b& b
1
0 m& p0 E6 S+ x, t: N0 j. y, ~2
3
4
5
& l5 b3 G* J7 f; c, w! A6
7
8
3 e( n* a* W' D: p9
10
  t) G% v" h# x) e11
) ^+ }$ N# r* L2 u( ~12
7 k6 m6 F8 E! X: ]13
- x! K! \9 w& _14
15
16
17
8 j7 s1 b, v% e. ^8 r18
- \( Y- g! P9 I- _7 d( U* c19
20
' w8 }' H- O) r& q21
22
23
8 V7 S8 d# F; X' S/ C/ ?24
25
26
27
28
- e' N( D. I! I8 x. y6 ]' t( m29
30
31
32
; f0 v8 L4 b, ^* d33
% m& G5 g; k/ c34
35
6 h+ r' ^4 _4 t36
37
2 J- R3 M; ^% E; ]38
39
  z6 G8 G8 c( k40
9 k9 x5 Y6 i$ M* K; L41
$ p; C1 s% P: `; ]42
7 Q: R( d2 s/ R9 q. s  N9 }43
  l* J( l+ d# A; d# {3 u# m44
45
46
47
" b3 s1 x5 C& T) i48
0 f* E' _% X  k49
50
3 ]2 G# D0 D7 z4 a* y1 e' m- ^# n51
52
53
54
55
56
/ U/ z' m! x: P! l2 k) B, ^  S4 c2 }57
/ ?* S' i' e# \% j3 q58
59
4 V) j6 ~+ F8 L3 q# Q9 l( S60
5 W, B3 E7 x) a8 ?/ P+ n9 \$ @61
62
' e# J3 S% v+ O63
64
65
+ Q) N; l8 s  S- \) ~! l7 v66
67
) \. r8 y. D: s5 f68
# b1 D* h( t* b# r7 e( Q9 x0 G& K& G8 }69
70
1 x; A! l% d3 Q% l0 j71
72
& Y& I, S! K- R! H# P4 C73
! `5 G2 b" I4 ]3 m74
5 l  }% B: r$ x1 D" U7 s5 M75
0 \8 ]- ~1 w/ R* V; r76
77
$ m9 b3 g3 h0 H; }7 @  t5 T78
79
80
& l; w0 s$ m8 p2 ~! d81
82
83
84
85
86
" U1 ^/ L( g6 o: D87
2 V( P. Y6 \2 V" o88
! o6 V& P, Q) P" L89
9 w6 J8 w+ a5 @4 S3 i! b90
第二步：在BCeShi.java中测试
ps：这里两个都在一个包中，如果不在一个包就要导包

9 _. ?6 L) c+ g6 [0 |package dierjieduan;
public class BCeShi {
& V2 y) D, P6 {! ~1 N  e2 n8 a    public static void main(String[] args) {
/ I5 v( o: ~7 z$ i( C. n        B p = new B();//建一个B的对象
7 W2 O& R' ~  ?! u5 n+ f! r        int[] arr= new int[]{12,34,55,423,5567,123456,1,4,5};//新new一个数组
        //求最值、总和、平均值
3 Z2 G& g- N- \: Q        int max=p.getMax(arr);//最大值
        int min=p.getMin(arr);//最小值
4 ]3 O& }: U9 x$ O: i8 s        int sum=p.getSum(arr);//总和
        double avg=p.getAvg(arr);//平均数
        System.out.println("最大值:"+max+"最小值为:"+min+"总和为:"+sum+"平均数为:"+avg);//输出
        p.print(arr);//反转前遍历（第一行）
- z  W/ ^  j( Y* X( h        p.reverse(arr);//反转数组
        p.print(arr);//反转后遍历（第二行）
        int[] copyarr=p.copy(arr);//复制数组arr给新数组copyarr
        p.print(copyarr);//遍历copyarr(第三行)
; k% c& s' R5 k7 V7 v6 Z- L0 U5 x* i0 O; F        p.print(arr);//排序前遍历（第四行）
0 M1 @4 x6 Y& X) a# B        p.sort(arr);//排序（冒泡）
# E& |9 k: L/ @" D: x        p.print(arr);//排序后遍历（第五行）
, G, G2 g1 l+ }( P% @; c        System.out.print("查找元素34：");//查找指定元素（这里针对的是排序后遍历出的数组，而不是最初的数组）
6 P! s& c  o4 n# x- L- _        int index= p.getIndex(arr,34);
# @6 B( g/ v$ i3 q2 O+ J" o) T        if (index>=0){
            System.out.println("找到了，在位置："+index);
  k& A9 ]1 Z# y' i        }else {
% f' S; j) b5 w7 ^( _2 }8 P            System.out.println("没有找到");
9 f1 V. i" {6 a  w+ W$ \/ _* y        }
    }
$ E: C: p4 L5 c. ^}

1
* v0 ?' ^9 K- j2 b" w2
3
4
1 a2 x  ^( Y( F* B4 L5
6
7
0 }% h  g/ B& o- ]  z# G  C& J! a# C$ L8
9
4 H+ ~% c# E" H2 n' f2 m( a10
11
12
4 q# J2 V  {3 m0 r13
. ^, n' Z4 }. m" R2 d6 t) m14
15
16
: z$ w- T7 t+ P9 t0 e# r0 d: t17
18
19
20
, d! Z1 v. Y8 D21
' k! F4 ?  z# p- O1 J. X22
6 L. U  O4 y& T# s$ i23
24
25
26
7 l5 O: C! v* C6 U7 x27
& @+ G# o8 M* U) L: V( U( R$ A' W* w28
运行结果（对应上面main方法中的代码注释来看）：

————————————————
版权声明：本文为CSDN博主「金士曼」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
7 ~5 Z. Z$ `+ D; S, e; W原文链接：https://blog.csdn.net/weixin_45869823/article/details/126754797

1051373629

感谢楼主的资料
: \# Q1 w8 E# Z. @