java-自定义数组的工具类

杨利霞

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

7 [  t! M5 J' f5 _java-自定义数组的工具类
9 h2 Z; Z3 T* o# X
文章目录
java-自定义数组的工具类
第一步：封装方法到B.java
9 U# o6 Y5 `( k* Z$ W4 {第二步：在BCeShi.java中测试
运行结果（对应上面main方法中的代码注释来看）：
java-自定义数组的工具类
' \+ F5 y# z' \; A$ T, k4 uJava—数组中涉及的常见算法有写到

求数值型数组中元素的最大值、最小值、平均数、总和等
0 P% Q0 U( Q+ m  \1 N数组的复制、反转、查找(线性查找、二分法查找)等等
- I  H, |+ ?) g% C数组元素的排序算法等等
1 a- Z9 v+ h& Y' F0 G5 V: ~5 b6 X! i这样的功能都可以封装到一个个方法当中
/ m' W& e7 A- |; I# w# o! a3 A! N
ps：这里和Java—数组中涉及的常见算法相比也相当于把之前分开写的比较冗杂的数组涉及的常用算法归类总结到了一起

' b# T0 f6 X! W- i2 k& b第一步：封装方法到B.java
package dierjieduan;
( T0 u9 z& H( R4 g7 z1 E: q7 e( q//自定义数组的工具类
public class B {
3 u/ o7 _0 }% X) Z( L9 o
: I* b  p, M% ~! I! B6 I. r  K    //求数组的最大值
+ w8 l8 b; G- S3 E4 J8 s3 I    public int getMax(int[] arr){
        int max=arr[0];
! y( F' J! E  N, O8 N$ u9 t% p        for (int i = 0; i <arr.length ; i++) {
            if (arr>max){
                max=arr;
7 ~7 F9 y( T1 G; }            }
        }
: f, P6 q. J5 U  b' f0 J9 T7 L1 g        return max;
    }

    //求数组的最小值
    public int getMin(int[] arr){
        int min=arr[0];
        for (int i = 0; i <arr.length ; i++) {
2 ?  d. e) _) f- ?* a' h            if (arr<min){
                min=arr;
3 \  F/ Y& O; o) W8 Q' e            }
        }
& i4 W2 c0 m8 @. H0 P: A        return min;
    }
2 ?9 c0 d9 X% t3 V  b0 ?
    //求数组的总和
! ?$ X6 {; J3 S3 O) E; ~: y    public int getSum(int[] arr){
        int sum=0;
        for (int i = 0; i <arr.length ; i++) {
            sum=sum+arr;
8 t- h  Z- G. j' f: f8 \        }
. y7 h! o* W! k( q. l! ^        return sum;
4 d8 @5 o3 l* S$ }  C% U    }
: Z4 \+ e7 \6 u0 {; C* t
    //求数组的平均值
    public double getAvg(int[] arr){
( r' F- _7 S; p3 C) y5 C9 L
        return getSum(arr)/arr.length;//注意返回值的灵活运用
    }
9 V) F8 A. l% _; s/ g
    //反转数组
6 n, [- i1 j; ~$ u3 R    public void reverse(int[] arr){
        for (int i = 0; i <arr.length/2; i++) {
$ e: i6 d- I2 B4 [* ~            int temp =arr;
            arr=arr[arr.length-i-1];
            arr[arr.length-i-1]=temp;
- u1 r$ z# [) N" _6 Y% f        }
2 _$ H8 V4 P  O' ]/ O: _6 d    }
# f- K* ?" X3 @) r5 F9 |) t$ F6 `+ L% N9 v
7 \$ q. t* E+ M% {) a    //复制数组
* \  v4 L1 ]" ?" Z/ h0 o+ O* y9 x    public int[] copy(int[] arr){
        int[] arr1=new int[arr.length];
4 _7 `& D6 F; E3 A9 K( F$ D        for (int i = 0; i <arr.length ; i++) {
- @- u- S0 q2 y5 O            arr1=arr;
* e* o7 a. g' k8 r6 D        }
        return arr1;
) v0 W4 G: x& m    }

: J9 T8 P- g: T' J' J    //数组排序(冒泡)
" f/ v9 I) N: L! o- O! F5 W    public void sort(int[] arr){
9 `/ u3 l0 o2 p; }; q# \0 H        for (int i = 0; i <arr.length ; i++) {
            for (int j = 0; j <arr.length-1-i ; j++) {
                if (arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
: }. M# R, n% y4 G5 ~9 Y                    arr[j+1]=temp;
1 N" ^- Q: ~6 C7 ]1 f+ |1 O& a0 z                }
            }
        }
: [4 @" P& b& T3 X8 g  o- ^    }
. J1 H! i' W5 \, B  b" E& k9 x; H
" B1 K. T# h! _& A% ]" U0 \6 p8 V    //遍历数组
' ?7 B: @3 \4 b3 u: ~( s    public void print(int[] arr){
        for (int i = 0; i <arr.length ; i++) {
' t" r# z) g0 A. |8 J0 K) F$ O            System.out.print(arr+"\t");
) D: e' g! `/ \+ ?% g        }
        System.out.println();//遍历后换行
    }
, P' ?! ]; D  b$ M9 [
    //查找指定元素
/ E& U- Z$ _( I6 A8 L+ F$ j& I    public int getIndex(int[] arr,int dest){//两个参数（某个数组找某个元素）
        for (int i = 0; i <arr.length ; i++) {
# n$ q* M3 t% z! g  }) N! g            if (arr==dest){
                return i;
) n8 ^2 L5 ~# r6 _            }
# b  g& N2 l3 z( H" S, [        }
1 _1 _2 I; _( o% ^) ~" P        return -1;//返回1个负数表示没找到
4 F# h* ^2 L0 v5 _/ r    }
}

1
2
: B6 ?; a; O( h" _8 A3
4 ~5 Y. {0 \) z" F% s4
* W7 }/ C2 c/ [5 i5
' X, G! J+ B3 C+ ?5 |6
7
, B  v$ f  y3 Z: V5 X8
' X! n# m4 R7 j' {+ L9
10
( J* v' C- u. v! G0 m8 S7 j11
12
- N1 J2 F- [: q2 `. P13
14
3 P9 h( I- W& a# R! J7 o% O1 R7 C15
16
: z( h7 ~" Z& n+ C. z17
18
19
  E$ X% T" M. t) Z- i20
21
22
9 d& U6 A( {" z- z  ]23
* O0 j6 Z1 Z; Z8 p: j24
25
26
27
+ |1 i+ q& x8 K  E9 }. E3 A" B28
29
! ?6 ]8 }1 W) D* ~  Q# W2 \# L/ Z30
31
9 e. [9 g4 ~9 ?32
33
34
35
1 |) E0 [& V( J1 u8 A: U+ O36
1 Y8 |, ?2 D# n: U# `37
- _' ?, u5 ~1 r1 G# t% R) F38
$ ?) ]# k  y* \0 v' e! J2 W- V" V39
40
' _: J/ b/ J# R" p$ D  f& [41
42
43
44
45
46
47
/ D- }& b0 u+ J9 ~7 L- V4 v48
- _/ e# p. [/ @) W; s' ]$ U49
5 n: B, t6 l! s50
, ]+ a& P8 p( |51
52
; j7 H( ~, {$ e; a53
54
55
6 }5 E. V) k1 R5 j* G' Y1 B56
+ F# W' }4 S$ ?( @57
58
59
% @+ ?5 a4 g5 t4 J60
61
62
7 u5 n" [7 U3 x4 `5 a9 O) Q% x63
0 }+ K/ ]: Q& F3 y3 ], Y64
65
66
67
68
69
70
71
72
! |% Y2 P7 h. ?$ @+ x* A73
74
" _* k. _! Y) \- @7 t75
! U" J, @! h8 h, a76
  }9 Y# V) d2 x77
. i" i# X: H+ S9 Z6 a% y0 F/ a& g" J78
79
0 P  p. G3 I8 O0 |80
81
82
83
84
# l+ F9 X  h( d: u; R, L. d85
* _2 Z0 q* o  i6 D6 _5 i2 D1 o7 k+ \86
& B0 y+ Z8 I: i3 }87
, m* |5 P4 n# R1 ~9 q# j88
89
90
4 Q0 r& b) F; ~1 G第二步：在BCeShi.java中测试
ps：这里两个都在一个包中，如果不在一个包就要导包
3 M: W- ~9 f( o9 w
package dierjieduan;
8 P8 {! B$ p* A6 |public class BCeShi {
    public static void main(String[] args) {
$ I# z& E8 Z6 G. g: M0 S) N" j  Q+ T0 g8 q        B p = new B();//建一个B的对象
$ ], W# r- \' t% ~        int[] arr= new int[]{12,34,55,423,5567,123456,1,4,5};//新new一个数组
% d" g* e2 T: v1 f7 ]: H3 T6 N        //求最值、总和、平均值
        int max=p.getMax(arr);//最大值
        int min=p.getMin(arr);//最小值
4 `; b3 L* v7 M, I  ^9 [        int sum=p.getSum(arr);//总和
& ~6 C' n; F+ ?" d! {        double avg=p.getAvg(arr);//平均数
; {( s* M, X0 p# |        System.out.println("最大值:"+max+"最小值为:"+min+"总和为:"+sum+"平均数为:"+avg);//输出
        p.print(arr);//反转前遍历（第一行）
        p.reverse(arr);//反转数组
/ c6 F) M( V) J3 c3 p: c9 g# q        p.print(arr);//反转后遍历（第二行）
        int[] copyarr=p.copy(arr);//复制数组arr给新数组copyarr
. {5 D. z7 z  n5 n+ H3 L0 r        p.print(copyarr);//遍历copyarr(第三行)
        p.print(arr);//排序前遍历（第四行）
! y1 e, A1 Q4 A* X: t: Y: W        p.sort(arr);//排序（冒泡）
        p.print(arr);//排序后遍历（第五行）
) @+ r( L% x  Q7 k8 }        System.out.print("查找元素34：");//查找指定元素（这里针对的是排序后遍历出的数组，而不是最初的数组）
8 r, R; w8 h) Q: |        int index= p.getIndex(arr,34);
# [/ w' i% s) p% b7 a        if (index>=0){
: N& j3 ]* `' Z+ {# C            System.out.println("找到了，在位置："+index);
        }else {
5 C* e6 L' M( I: R7 ~            System.out.println("没有找到");
/ |4 _! |; g4 K5 y        }
- H3 ?$ p' V+ @" }/ k) T# ]    }
}

! T# H) q; C) \& M' K% M1
- d' ~$ M- K3 `* P( Z9 d: C2
3
4
5
! ]& s4 F- A; h" P$ Q; j6
7
; |" F3 D1 v: M% A. F- t8
7 {1 S, ~" w) g( Y9
10
11
% P5 T; q( K9 |: T5 a5 g) ]12
13
14
15
16
: v# d# T4 t, P- V# y  V17
18
19
20
21
$ s- ^4 h3 D. V" X22
23
24
25
  {7 p7 @8 X# Q' P0 z) s9 z" p26
+ Z; Z4 U+ D+ P% h+ ]27
; _7 a  H4 `* V' K28
7 \) |/ D( b' b+ ?" {2 O* l% n运行结果（对应上面main方法中的代码注释来看）：

————————————————
版权声明：本文为CSDN博主「金士曼」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
  \$ A$ }/ k) e; N8 o4 r; o原文链接：https://blog.csdn.net/weixin_45869823/article/details/126754797
) ~- Y! i; G# n+ |& P* p# Y

3 s3 E$ l! t! b

1051373629

感谢楼主的资料