java-自定义数组的工具类

杨利霞

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

, V3 s6 A* C! Q: q+ c+ Ujava-自定义数组的工具类

8 p) Q& o  s/ }+ F% E3 D文章目录
java-自定义数组的工具类
: P6 s3 T  a! @! T# d/ a# A第一步：封装方法到B.java
1 y6 H% }( ]5 C# I0 Q  Z第二步：在BCeShi.java中测试
运行结果（对应上面main方法中的代码注释来看）：
8 }2 H/ a. E) Ujava-自定义数组的工具类
) S  K" c" Q& u* cJava—数组中涉及的常见算法有写到

6 N7 A: {# z# f. r求数值型数组中元素的最大值、最小值、平均数、总和等
数组的复制、反转、查找(线性查找、二分法查找)等等
) R9 f2 n* d, ~2 U( v) d数组元素的排序算法等等
这样的功能都可以封装到一个个方法当中
4 U  t* f7 T0 l$ b) d
ps：这里和Java—数组中涉及的常见算法相比也相当于把之前分开写的比较冗杂的数组涉及的常用算法归类总结到了一起
1 _  C* G7 {' P
第一步：封装方法到B.java
4 c9 s$ b" _: |5 t+ npackage dierjieduan;
/ O8 l* f$ i3 v9 M; U' N; `5 h* G//自定义数组的工具类
0 w" v: P% j9 {! epublic class B {

+ q$ l* R: x; T    //求数组的最大值
0 `1 o2 y( @" \& ?. Y    public int getMax(int[] arr){
        int max=arr[0];
# r9 L" R2 K+ h3 ?        for (int i = 0; i <arr.length ; i++) {
            if (arr>max){
                max=arr;
            }
$ H# ~/ X3 P8 U0 [* Z2 g+ b        }
        return max;
    }

9 c. F2 b1 e* Y* A6 h    //求数组的最小值
    public int getMin(int[] arr){
, R- a; l0 N' U) ?; z8 s        int min=arr[0];
* ~: Y2 j- b- W" B        for (int i = 0; i <arr.length ; i++) {
            if (arr<min){
  I0 x% N6 Q2 F2 y( ?                min=arr;
) E; y! I5 c% z/ k) e; y) b            }
        }
        return min;
    }
" Q+ k, Q! c# ~
    //求数组的总和
    public int getSum(int[] arr){
        int sum=0;
        for (int i = 0; i <arr.length ; i++) {
            sum=sum+arr;
/ @3 s) {/ `% V2 P) U0 a& ?        }
7 q& C, b* G+ h. A/ A        return sum;
    }
# L5 i& _. O# s" M  V) D
/ i! R  n) j. E* B* e# x3 L    //求数组的平均值
  a4 r$ F" }' R0 b6 S( m    public double getAvg(int[] arr){

# A0 s# u/ B8 `        return getSum(arr)/arr.length;//注意返回值的灵活运用
/ ]2 P% k+ M4 m    }

    //反转数组
    public void reverse(int[] arr){
! d+ ?/ x2 w) |        for (int i = 0; i <arr.length/2; i++) {
7 z, @0 @3 j7 T. ^) Q8 N            int temp =arr;
            arr=arr[arr.length-i-1];
7 ?  T1 ]3 ~2 Y; S; y: e9 W- y& e            arr[arr.length-i-1]=temp;
' q" c8 m% F3 ^( t  X        }
    }

$ {  b7 c  [" F7 A0 ^    //复制数组
    public int[] copy(int[] arr){
        int[] arr1=new int[arr.length];
" D! G) r4 W" S9 |$ i8 U+ {        for (int i = 0; i <arr.length ; i++) {
1 x# ^5 ^+ j9 ]            arr1=arr;
        }
        return arr1;
    }
( k' U3 u- C* x8 C# [3 E. Q  I
    //数组排序(冒泡)
    public void sort(int[] arr){
        for (int i = 0; i <arr.length ; i++) {
8 n4 i  _: j! R            for (int j = 0; j <arr.length-1-i ; j++) {
) U) c, {1 q: m6 A- ~                if (arr[j]>arr[j+1]){
) x6 V! D6 E1 v$ k                    int temp=arr[j];
7 j5 e( Y' ~9 ~0 g+ Y                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
- u0 Y  p! C9 p1 t6 s* s            }
        }
    }

    //遍历数组
    public void print(int[] arr){
' G6 D, R! C. ^' M        for (int i = 0; i <arr.length ; i++) {
# u- I0 M) N, [: f- y$ m+ K            System.out.print(arr+"\t");
        }
) }  _4 d/ P6 w0 j# s        System.out.println();//遍历后换行
6 f" d' t; X& x    }

: ^$ P2 ?3 U+ Z* j; D' S$ A! `! o$ G    //查找指定元素
" `$ z) U0 a$ W! ~' I1 t    public int getIndex(int[] arr,int dest){//两个参数（某个数组找某个元素）
        for (int i = 0; i <arr.length ; i++) {
! O0 ^9 Y9 x& r# d% y3 ~            if (arr==dest){
                return i;
            }
! S. r. d9 e4 n: J& O. w+ I- ~        }
        return -1;//返回1个负数表示没找到
    }
9 E5 a4 V* Z! ?}
( C$ E# ]8 P5 ^; i' G2 [5 m8 _
" Y/ d5 G. [+ G4 E* T8 M1
2
3
4
4 h* |$ I* V4 g$ W! k5
6
% d% C' s* K& L- J; P) d7
6 S/ F4 k& ~1 F# t% i8
9
10
11
" n9 J( w! E9 F5 z$ |& ^. Y12
13
14
+ ~2 g8 t9 F# X- ?* D2 R- k15
% G5 b: E: e0 M5 w4 r/ |16
* o2 N. M: E& V# K# c7 N17
. r+ D3 ?) r0 a4 r3 [18
$ a% w4 u. w3 I" S. S6 D. D$ z# j19
9 ^% i' e" J. s/ S8 P. z20
21
# [9 }& u, ]9 N. C9 G2 O22
23
( G& V4 b# Y& v5 _# V2 {24
25
6 H/ @, o! k! Y. v# F5 r+ P1 Y26
1 L, S' a$ X& F7 s27
28
  g, \7 s; s" w29
30
0 M2 H: k7 A* z* {1 ~31
5 b: a5 w' K' g" l; Y/ \1 }7 `32
% _$ \. ?# K! H* t33
34
+ G, a- B& L+ T0 {35
36
  T) d1 |$ z  T! j% z37
2 a  m) ^3 c( o% o38
39
40
8 [/ l8 d9 [( N3 y4 `41
42
43
% {/ d# Y/ L/ T8 H/ o  g% H" D44
45
( V8 U. S5 b0 c+ c! ^6 x) _46
47
) o9 L! I. {1 z; A; _4 C48
( e! e- F1 D' l( P* C. j; Q49
50
51
52
53
54
9 ?$ d  Y4 l1 g, S55
56
57
58
  Y6 i7 L/ s" K59
( O& }. N* P4 Q) @# G" P60
61
$ r) S/ b$ l; }& _62
: A! {* @+ Z/ m" K/ ^5 }5 K0 I63
; t8 n1 k0 Q& l6 g9 K64
65
66
# ?1 ~. H( q$ R7 G67
68
69
70
% h* d, e8 C/ y3 J! H71
72
& J. o2 w+ l# q+ G4 c; @+ N$ u73
74
/ J. l( {% k% A& W; j5 M& B75
% Q& D/ e% b: y) N0 {8 M/ M" e76
5 m0 b" z% t: i. d4 R" v% a77
% F2 e9 G/ f3 ]7 ?3 g3 x* [; U3 i78
79
& }: G! C( x( B; R  u8 l% A80
81
  \) w3 M1 v* y$ x82
83
8 M2 m4 }  B% B. x# j7 ]84
85
7 H  z' A0 _/ @9 v5 x( k' p) {# c; @* T86
87
88
89
90
$ ~7 l. E3 B4 y. x! J6 \, }第二步：在BCeShi.java中测试
' }# Z6 D7 x2 V: i  L9 P7 o( n: Pps：这里两个都在一个包中，如果不在一个包就要导包

+ v$ f: c; ?3 c2 N, \package dierjieduan;
6 ?& i8 c) P; i! Y; z- }public class BCeShi {
    public static void main(String[] args) {
        B p = new B();//建一个B的对象
& T5 c; O+ `2 s5 G5 M        int[] arr= new int[]{12,34,55,423,5567,123456,1,4,5};//新new一个数组
* p# {& ?; e  K( w8 N& d! K        //求最值、总和、平均值
/ K9 o4 `) O4 C4 y, j6 p        int max=p.getMax(arr);//最大值
7 S% _9 y( K) M) X        int min=p.getMin(arr);//最小值
" G0 a: j1 d9 O5 C, F6 z+ H        int sum=p.getSum(arr);//总和
5 B6 g! ^9 B2 K, [" m/ g( I        double avg=p.getAvg(arr);//平均数
        System.out.println("最大值:"+max+"最小值为:"+min+"总和为:"+sum+"平均数为:"+avg);//输出
4 w& M( O1 l, H" v7 Z; a        p.print(arr);//反转前遍历（第一行）
        p.reverse(arr);//反转数组
        p.print(arr);//反转后遍历（第二行）
        int[] copyarr=p.copy(arr);//复制数组arr给新数组copyarr
        p.print(copyarr);//遍历copyarr(第三行)
& z$ F, ^: T/ z( N0 K7 G1 Z        p.print(arr);//排序前遍历（第四行）
        p.sort(arr);//排序（冒泡）
& W% w' a' \) A1 j( N) r+ J        p.print(arr);//排序后遍历（第五行）
  B! ?# ~: r# z$ ?" V  Q: F        System.out.print("查找元素34：");//查找指定元素（这里针对的是排序后遍历出的数组，而不是最初的数组）
        int index= p.getIndex(arr,34);
7 f$ V7 I. C9 P. s7 Z        if (index>=0){
1 K- G) u: P: F0 t% J            System.out.println("找到了，在位置："+index);
% H( B. M4 `0 G4 p1 ~        }else {
' P% x6 |0 V) p+ _6 n" V            System.out.println("没有找到");
: B3 N% T0 `# J" \3 p8 O        }
/ e7 U* b0 `, f    }
}
/ {) [" v6 }! P- ?; d
5 S2 w5 l0 g# |1
. e9 ?3 m. T# S2
0 T2 s$ r5 k& N3 L3
4
5
6
9 e3 \$ Q, D& F' u$ J+ n1 h7
8
9
2 R& q0 x! V. r) j( {10
' g+ Q" L1 K/ t8 {* v: c11
12
& `' ]1 ~  T) Y/ }6 b1 p% W13
6 y) Y( r: j. W' ?& n8 p# `14
+ Z* z. e. ^' k. J2 y15
/ O  u$ r2 j4 \; G9 y16
17
18
19
6 ^. R0 v5 H3 z( I20
, L# e6 w9 w% `. o21
22
23
24
) x0 j0 |8 y+ Y$ |3 B( H25
! A% W) B! Y6 N26
27
( F) t* _  \1 K* B- |4 ]0 n* P) v28
9 _- s4 y, u6 @- E运行结果（对应上面main方法中的代码注释来看）：

————————————————
) w! G5 K/ \3 ^( r; z版权声明：本文为CSDN博主「金士曼」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_45869823/article/details/126754797
7 Q0 X- X. A4 k/ K
# p: \% R* s6 j0 A) U8 |
" z0 q' E1 n8 q7 v

1051373629

感谢楼主的资料