java-自定义数组的工具类

杨利霞

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

java-自定义数组的工具类
3 p/ K% ~) }8 y% h7 o7 J! @7 g% x
2 ?, M5 e1 p  c文章目录
9 j) K( Q: U; Y: o! n* D% Z% Njava-自定义数组的工具类
第一步：封装方法到B.java
第二步：在BCeShi.java中测试
8 A, q+ ~2 n- C  f6 r: C运行结果（对应上面main方法中的代码注释来看）：
+ ?  b: S0 ~' w/ @/ F, Q- W! ejava-自定义数组的工具类
% Y/ e. {1 T  k0 p. XJava—数组中涉及的常见算法有写到

求数值型数组中元素的最大值、最小值、平均数、总和等
( e! m0 a9 d& X* T( @: y数组的复制、反转、查找(线性查找、二分法查找)等等
1 w1 z2 W4 q1 D& s/ G3 W! ~数组元素的排序算法等等
3 _6 x% Y, a1 D- R* @# ^. I& l' h( M这样的功能都可以封装到一个个方法当中

  A2 A% T0 W# b4 U- Hps：这里和Java—数组中涉及的常见算法相比也相当于把之前分开写的比较冗杂的数组涉及的常用算法归类总结到了一起
- r- |6 v1 }7 V" i+ w/ c% ?
4 D) ~" f. o: N, t* i* D第一步：封装方法到B.java
package dierjieduan;
/ k( i% _. x8 n//自定义数组的工具类
8 [5 {; d, ]5 k! Kpublic class B {

    //求数组的最大值
    public int getMax(int[] arr){
        int max=arr[0];
        for (int i = 0; i <arr.length ; i++) {
            if (arr>max){
                max=arr;
            }
        }
        return max;
    }

4 k. T) o+ z0 D: Z( P    //求数组的最小值
    public int getMin(int[] arr){
        int min=arr[0];
        for (int i = 0; i <arr.length ; i++) {
+ Z8 D% j( G1 I0 [+ @            if (arr<min){
; @2 U% N% P& R8 I% K                min=arr;
6 J+ E6 S2 A; x7 W) g9 J. z6 Q: W) H            }
        }
        return min;
# y7 F6 @- ?# g) ]    }
/ e# R+ o7 R3 `
    //求数组的总和
4 v# t" J4 M6 L    public int getSum(int[] arr){
. n6 X, T0 I2 N: N! z( u+ Z        int sum=0;
0 \' F  K/ G9 _4 Q        for (int i = 0; i <arr.length ; i++) {
            sum=sum+arr;
+ Y7 f4 ]0 }8 ?' f/ J# r7 ?! s        }
$ l. y% d# d# b) @8 v% Y        return sum;
    }

: A9 W3 K+ e- R9 }. T4 s    //求数组的平均值
    public double getAvg(int[] arr){

        return getSum(arr)/arr.length;//注意返回值的灵活运用
    }

1 O% Z$ t5 K" J    //反转数组
" N% m$ M9 l/ c% D    public void reverse(int[] arr){
! ^, U# a6 [! Y: f        for (int i = 0; i <arr.length/2; i++) {
            int temp =arr;
  `2 ]( A/ R. Y+ l' o            arr=arr[arr.length-i-1];
* Q" m  Y* N8 P7 {) |: l, s            arr[arr.length-i-1]=temp;
        }
! a% |) ?( ?4 o& Z0 {; w2 Q    }
2 A+ s" {, ]& h& p/ A
+ r6 M" {6 R) V7 J- h9 p  }8 F! C    //复制数组
$ p. W' E8 @7 x" n6 @    public int[] copy(int[] arr){
        int[] arr1=new int[arr.length];
/ E1 `: N' T, Q3 k# {. G        for (int i = 0; i <arr.length ; i++) {
5 r4 a+ }, [' H            arr1=arr;
        }
        return arr1;
    }
- W2 _1 y8 E: J
% v5 Y$ F6 E4 b( M! D1 {- G    //数组排序(冒泡)
/ c0 g3 k- U' c, b: T  }% D3 V* @/ N8 V    public void sort(int[] arr){
        for (int i = 0; i <arr.length ; i++) {
  a7 A/ X7 q3 @1 }. |            for (int j = 0; j <arr.length-1-i ; j++) {
                if (arr[j]>arr[j+1]){
                    int temp=arr[j];
- B! `2 ?6 @) h# M4 L, j                    arr[j]=arr[j+1];
; a- O# B) V! S                    arr[j+1]=temp;
& t$ g* k6 G2 U0 Y* _$ g% R% F                }
* f& d; j; |4 [5 W, N, X            }
& S8 R' p3 N8 S8 W+ ?! R0 w        }
; p: E/ |- U9 _" `8 n    }

    //遍历数组
$ u: Y% B) c* H# W. X    public void print(int[] arr){
" G8 E$ h2 @$ w/ Y% Y! `        for (int i = 0; i <arr.length ; i++) {
% d0 c* f( C+ o! S3 O% X, t            System.out.print(arr+"\t");
; I- v0 u( z/ m        }
+ _6 w) Y; X4 b# P) J) R4 f        System.out.println();//遍历后换行
    }
# N" d/ L. ^8 w
    //查找指定元素
8 J# c7 `# O6 y* H. R4 I    public int getIndex(int[] arr,int dest){//两个参数（某个数组找某个元素）
        for (int i = 0; i <arr.length ; i++) {
6 f: q8 ^; l2 {: c! L            if (arr==dest){
$ G9 |( U2 R* l+ y" F# g                return i;
            }
        }
        return -1;//返回1个负数表示没找到
    }
  o- p: R: g& j5 r5 j% R. \}
  o" e. R* T+ u' w% Z5 ~
% A+ ~( Y& N$ G6 D$ Y1
% J9 u' ]$ {" l# @( t+ P! p/ {2
% ]4 l8 t$ y, j" \2 R* d3
* I% v. ~% C& Q" x/ w# n4
5
7 i" E9 x' O) O- I0 |. [& w  X6
/ k* t# T& r: g+ B. ^0 h7
8
$ Q- E* y0 V4 z& s7 C: M; o, C9
10
11
12
; Y0 z8 b" F, S! S3 J& m) C13
! {) ]3 P# G. o14
15
; F4 }- m. p( H8 C# G& I! j16
17
18
19
20
, N; u  l* k7 d# U* o+ \2 O21
% P0 @/ c& [0 ?4 D! |. D22
23
# r6 d. S$ a' e* c9 t& V- s24
25
0 t* p' j9 S2 M! q26
27
28
29
. t7 }. e( S9 a$ X* x5 ]30
31
8 \& J8 m, \7 p( E32
33
34
% O7 I$ c: N/ _! a0 i35
: s9 z+ h2 A5 ?$ h% b& ?. e36
, b$ k4 _$ `! F" X+ |, M/ q37
38
$ V) Q- i' P4 x8 U) H39
40
41
42
$ R9 [/ a" `  L, w( s43
44
+ x5 v- E5 |5 c: Y% W0 W45
46
47
) S+ }5 q: b  a# R- ?( T/ [48
49
2 x& ~0 T% c1 E6 U  o# M3 Y50
51
52
53
54
3 X- t0 n. V: F0 c55
56
% l! y' @" v6 m57
58
59
( l' z6 m9 A8 J/ G1 o! {5 o60
61
" F, E; n" M. K  |62
! \0 n: s- i; e5 _63
/ c) r) {0 M* Q64
/ y3 D% T8 a! d7 m0 ?65
9 R4 w- e! V9 a2 S66
67
  O2 v4 E* d1 X5 W- h: t* I6 a' h: k68
69
70
71
72
73
74
5 L* S: J+ O1 q4 _$ D, @/ C75
3 l- R* d$ L0 N  P1 Q76
77
/ [9 k+ Q6 W9 c( v3 d0 O78
' Z3 B6 C1 q1 w# q7 t& A# W# c1 D79
& q3 O* B. b# ^+ c* d, Z2 @80
81
) G  v2 M! [7 e82
83
" U  K) p2 c2 y& T' |, u# ?# n' V2 [84
85
; a3 ]3 ^3 K# W86
87
88
9 M+ k+ P* M( t$ C( i8 O8 }( q89
90
第二步：在BCeShi.java中测试
7 F7 e- [, @, a; b$ t0 o, d% ?" R7 Lps：这里两个都在一个包中，如果不在一个包就要导包
5 |8 U+ R* M' M/ u* @
) \( O8 E) J0 M' B- hpackage dierjieduan;
- J7 m" e8 N8 V  w; Ipublic class BCeShi {
    public static void main(String[] args) {
        B p = new B();//建一个B的对象
        int[] arr= new int[]{12,34,55,423,5567,123456,1,4,5};//新new一个数组
2 d6 Z: h- x+ p. L$ h        //求最值、总和、平均值
        int max=p.getMax(arr);//最大值
        int min=p.getMin(arr);//最小值
        int sum=p.getSum(arr);//总和
        double avg=p.getAvg(arr);//平均数
        System.out.println("最大值:"+max+"最小值为:"+min+"总和为:"+sum+"平均数为:"+avg);//输出
8 Y0 r8 n- v* v. I        p.print(arr);//反转前遍历（第一行）
        p.reverse(arr);//反转数组
# K2 k5 _4 f3 Y( O! X        p.print(arr);//反转后遍历（第二行）
        int[] copyarr=p.copy(arr);//复制数组arr给新数组copyarr
        p.print(copyarr);//遍历copyarr(第三行)
2 ?6 H) i- [) M        p.print(arr);//排序前遍历（第四行）
        p.sort(arr);//排序（冒泡）
        p.print(arr);//排序后遍历（第五行）
        System.out.print("查找元素34：");//查找指定元素（这里针对的是排序后遍历出的数组，而不是最初的数组）
        int index= p.getIndex(arr,34);
2 [  h8 ]; z9 Z9 s        if (index>=0){
            System.out.println("找到了，在位置："+index);
, _- Y* i1 G! @+ H        }else {
            System.out.println("没有找到");
1 d+ s8 |( g- G6 \1 A        }
    }
}
. I$ ^. u) A" X
% y) ?/ _4 W$ |9 P; F1
5 i# o- N* N3 j# Q% S2
- a9 Y. ]/ a( O3
4
5
6 l) \/ S, I( a2 P& `6
8 y" Y- q9 h3 i" p7
8
9
  C9 F5 H3 x/ Z* R# r0 B- ?10
11
% F8 P( H9 b6 y1 U12
13
14
6 B- @8 [. t- X" |' ]15
16
3 k* _3 D3 |8 R  U) i, a8 @17
9 t, `' f! S2 F2 k$ q: Y18
/ b8 Q" m. t7 ?1 _/ S4 @19
20
2 M, J! F) ], ~# ~+ Q9 ^21
22
23
+ h. g; y6 w8 [- p; [2 e24
25
7 z: y5 C' {  k& v6 Q26
27
. U9 o: D" Y! P; Y) o28
运行结果（对应上面main方法中的代码注释来看）：
4 D! [5 H' B& Y
————————————————
版权声明：本文为CSDN博主「金士曼」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_45869823/article/details/126754797

1051373629

感谢楼主的资料