java-自定义数组的工具类

杨利霞

java-jajava-自定义数组的工具类va-自定义数组的工具类自定义数组jjava-自定义数组的工具类ava-自定义数组的工具类
0 D- z1 @% c7 W  V* c8 K/ o
! c$ T& {( G6 ljava-自定义数组的工具类

4 y. f8 P) R) l& Q) F" k7 @. |7 ?文章目录
java-自定义数组的工具类
  y. t0 D) x) e* B第一步：封装方法到B.java
第二步：在BCeShi.java中测试
" s% W2 Y, d: x' U运行结果（对应上面main方法中的代码注释来看）：
. ?( N( x3 o# p& Yjava-自定义数组的工具类
! v( {+ r8 O5 f1 p2 E1 H6 X7 eJava—数组中涉及的常见算法有写到
8 a6 X; H  X. b9 U. v2 D2 Q6 ]+ Y
求数值型数组中元素的最大值、最小值、平均数、总和等
3 H* w* i( E8 Y数组的复制、反转、查找(线性查找、二分法查找)等等
8 j5 _1 Q$ }3 H数组元素的排序算法等等
这样的功能都可以封装到一个个方法当中

/ m% e5 l( f9 v; l4 lps：这里和Java—数组中涉及的常见算法相比也相当于把之前分开写的比较冗杂的数组涉及的常用算法归类总结到了一起

8 m: r8 ~. i( n) Z' b第一步：封装方法到B.java
9 e/ p0 T# Z! \7 W0 d: L+ qpackage dierjieduan;
//自定义数组的工具类
public class B {
" Y' s# @4 d1 e$ Z4 ?" x% w! z
' W! t3 C1 R% V6 a    //求数组的最大值
    public int getMax(int[] arr){
- |/ I( c$ q/ I0 l/ a        int max=arr[0];
        for (int i = 0; i <arr.length ; i++) {
            if (arr>max){
0 b) J" r+ N6 S6 D0 D; R; w                max=arr;
            }
        }
: O' C* x1 }- b6 V        return max;
    }

% v. `8 X% g6 N! w5 p    //求数组的最小值
    public int getMin(int[] arr){
2 G; P7 G& |6 d7 W7 p        int min=arr[0];
8 j$ g; O7 x7 ~        for (int i = 0; i <arr.length ; i++) {
2 l5 u; h- ~6 M1 ]3 D4 P            if (arr<min){
5 C) U2 I/ o4 B( h' n) h2 S                min=arr;
            }
        }
) q, D# Q9 `" g' J% ]0 k        return min;
" o, ^+ @' j% ?% v    }

    //求数组的总和
! B  ~) R$ |" ~    public int getSum(int[] arr){
        int sum=0;
        for (int i = 0; i <arr.length ; i++) {
            sum=sum+arr;
        }
  Q- O, ~5 ?" i. H% Y; ?        return sum;
* q* l1 n8 g9 p* y    }
6 I4 [6 {4 ^# u% e/ ?) O
- h/ n6 p" X4 s    //求数组的平均值
    public double getAvg(int[] arr){
0 ]+ L- K) _4 J% |2 `
        return getSum(arr)/arr.length;//注意返回值的灵活运用
, H; i$ X" V1 L" ?) H% e& {    }
  w& [$ j: }, l  p6 v' W
    //反转数组
    public void reverse(int[] arr){
* |* X) ?  Y# e! F0 u# P1 a7 t        for (int i = 0; i <arr.length/2; i++) {
            int temp =arr;
            arr=arr[arr.length-i-1];
! K3 a( [" |4 E4 g5 r& I: U- h, h& O            arr[arr.length-i-1]=temp;
        }
; A# j- l: _- y    }

) \7 t  j+ d% u4 g+ Z# t" s    //复制数组
    public int[] copy(int[] arr){
        int[] arr1=new int[arr.length];
, ]- m! k8 F1 H2 x, S7 S        for (int i = 0; i <arr.length ; i++) {
            arr1=arr;
        }
        return arr1;
    }

; V3 S8 |9 L" D+ f7 ~* {, G. L    //数组排序(冒泡)
    public void sort(int[] arr){
        for (int i = 0; i <arr.length ; i++) {
5 o1 S* j$ a& T$ C( g& }" J6 f            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];
3 E7 R5 n+ [) W9 Q5 S& i' D( Q                    arr[j+1]=temp;
5 `( L! w8 z8 V: V9 K0 E& k                }
            }
# e( ], c4 u# L8 {        }
    }
& r; B1 m) c3 `5 v, G9 v
6 c: a+ E3 J( O: m# y) e    //遍历数组
    public void print(int[] arr){
        for (int i = 0; i <arr.length ; i++) {
            System.out.print(arr+"\t");
2 k" I1 I2 `1 u4 L' P        }
        System.out.println();//遍历后换行
- c& s" N+ X# E  B    }

    //查找指定元素
    public int getIndex(int[] arr,int dest){//两个参数（某个数组找某个元素）
        for (int i = 0; i <arr.length ; i++) {
) n0 M  t" ]: V, p  j6 j/ T+ G; Z            if (arr==dest){
                return i;
( o" a" W. U8 `; @7 h            }
* t8 N0 f# `! x5 G, R5 L        }
        return -1;//返回1个负数表示没找到
    }
1 v9 s+ g* x- \5 }}
( j" ?  f! S: w% o2 e* n
; n6 E8 K4 w% c) r) d6 U% P1
2
3
4
5
6
7
8
8 [( N! p$ a2 @6 e3 I9
10
# I' b- a# ]8 Q/ |5 I11
12
+ |! g1 h4 ^5 N9 i" ~13
14
15
4 k8 G9 l. o! b- N" s! h16
$ u, ^' v* ~7 E  }- [/ D* }+ C17
18
19
20
# K; ~6 r5 e7 B3 a; n% j21
22
23
24
25
# `) w2 n' L' f/ C9 V5 e26
1 t! {9 \6 J* B9 ?27
$ h+ W+ R; M! r28
  h* K* W) M5 p$ J9 K29
) p, [# ]3 d3 X$ V/ D30
$ z& V5 k# p6 s; N" Q31
32
' P+ Q3 C: w1 k& M% r6 d33
34
35
$ \8 s! Q* `$ {6 S6 S1 ~36
37
38
2 z* }4 C4 ^3 m. P8 p- W, M39
1 z. J! I: i( k" F7 p" {# A: u40
41
9 }0 B4 \. D2 T) T2 [$ ~42
43
0 t9 l7 A1 p. f. h" N8 l5 K( g  y44
' y- V0 a' l- ^7 l5 G% ]1 J7 w45
46
0 {: H2 M' n# E! B4 c+ ?' f. N' l& R47
* j+ l  i8 P8 r( h) }$ c! _48
' i2 z% e9 m8 D( U! k6 E! _! Q2 U49
. l# v. v( x( ]) o50
51
1 X; s$ M7 _9 I8 P$ a$ f! k/ F52
( J$ [( K, @! M% K* q53
54
55
56
57
: C: k" V% |" G2 L7 q58
59
" ?7 v# `1 f2 X6 @& R60
  A7 _1 s& s0 I1 b  u61
( i' K( n6 G4 m  [' ]/ L1 ?62
+ ?: A: }/ S. R7 ~. T63
7 K% \+ ?5 g# W$ }64
/ b2 U; Y1 \" @( c% H: O65
66
67
6 D5 c5 v- v$ a$ L/ A8 D+ i% W68
69
70
71
72
73
+ m+ M1 H4 _  \$ }  u3 u, \74
* ^5 t- O) _2 g% I75
  d9 @; B* ?9 F) `76
9 z/ x4 e7 S- F9 g- a4 v77
4 t, \2 y0 y" J! M) N/ T. y+ B78
4 |7 `, r2 l) g( U7 W( Y79
) X: {3 r' C8 U6 s: A80
; f  x% j* X% u1 t7 z81
82
* _3 U  o1 v5 e0 t83
84
85
86
87
8 {; P; S  v) Y# \7 j) f( c5 E88
. G% A# D' J4 k: @2 O7 g$ ]3 W2 K( d89
) S: i; X& ?2 O90
第二步：在BCeShi.java中测试
. i7 R/ @) U. Z1 s. Vps：这里两个都在一个包中，如果不在一个包就要导包

2 ?! o# O# I/ a( @$ ?8 Z- l0 npackage dierjieduan;
3 D9 m! W- D. ^( g0 }. Opublic class BCeShi {
* T& n+ F$ Y( M8 _  H    public static void main(String[] args) {
        B p = new B();//建一个B的对象
. V0 M4 q. Q- B- ?/ Q# w        int[] arr= new int[]{12,34,55,423,5567,123456,1,4,5};//新new一个数组
        //求最值、总和、平均值
        int max=p.getMax(arr);//最大值
        int min=p.getMin(arr);//最小值
        int sum=p.getSum(arr);//总和
% j2 H. |( X- |, v) }7 b6 }        double avg=p.getAvg(arr);//平均数
        System.out.println("最大值:"+max+"最小值为:"+min+"总和为:"+sum+"平均数为:"+avg);//输出
- {1 Y, K$ c1 }& _: G1 C( k% l9 t- @/ r        p.print(arr);//反转前遍历（第一行）
0 g* u3 T* m& C8 S        p.reverse(arr);//反转数组
5 f) |* b$ j- n( C( k) I        p.print(arr);//反转后遍历（第二行）
        int[] copyarr=p.copy(arr);//复制数组arr给新数组copyarr
" D+ I6 Z1 x0 U8 f! ~; ?        p.print(copyarr);//遍历copyarr(第三行)
        p.print(arr);//排序前遍历（第四行）
        p.sort(arr);//排序（冒泡）
; t* Z1 p4 S0 r6 b5 v6 }/ Z        p.print(arr);//排序后遍历（第五行）
        System.out.print("查找元素34：");//查找指定元素（这里针对的是排序后遍历出的数组，而不是最初的数组）
8 U8 j6 }2 J' V. e. L. K% W9 I        int index= p.getIndex(arr,34);
3 Q/ M. B1 n1 o        if (index>=0){
            System.out.println("找到了，在位置："+index);
        }else {
3 v/ _2 V, D2 \$ ^  K% a            System.out.println("没有找到");
        }
/ K( j3 v8 {6 K1 B+ H( D    }
}
9 @9 ~, o6 k: ?
1
2
3
4
5
6
7
9 s$ ~! R. z) Z' Z7 g% w2 }8
9
% c* d2 g" u. O$ y7 L* [10
% W8 {' K( b% S# U11
5 b& n- L2 Y& j1 z2 L- Q12
* V) J# ]0 q. ^+ [. O9 R5 m13
/ O. b; D3 `" J  {) A14
' O9 a1 i7 Z$ _15
16
0 L8 C9 z. P, s5 X6 y3 b( q17
; m+ [* G/ d+ ?. G5 {18
, }3 o0 `# B; N1 n+ i19
20
! R% h% t2 `4 k' l$ {2 o4 z6 C21
22
23
0 r5 K+ B+ O; j5 s24
25
0 M9 [6 R9 f9 ~1 g26
* J3 [8 k7 a1 d, M# }# [' Z7 I27
28
运行结果（对应上面main方法中的代码注释来看）：
2 m0 [7 S5 |- l: i8 \' e
————————————————
版权声明：本文为CSDN博主「金士曼」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_45869823/article/details/126754797

1051373629

感谢楼主的资料
4 b( M1 F9 r7 z2 K3 z$ b0 H