Java——int、double型数组常用操作工具类

学了数组之后,感觉有好多操作需要经常去写,很不方便,因此自己做了一个工具类,方便调用,方法可能不全,希望大家可以添加,让我使用也方便一点儿。

  1 public class ArrayUtils {
  2 //求数组的最大值(int)
  3     public static int getMax(int[] arr){
  4         int max = arr[0];
  5         for(int i = 0;i<arr.length;i++){
  6             if(max<arr[i]){
  7                 max = arr[i];
  8             }
  9         }
 10         return max;
 11     }
 12 //求数组的最小值(int)
 13     public static int getMin(int[] arr){
 14         int min = arr[0];
 15         for(int i = 0;i<arr.length;i++){
 16             if(min>arr[i]){
 17                 min = arr[i];
 18             }
 19         }
 20         return min;
 21     }
 22 //得到数组最大值的下标(int)
 23     public static int getMaxIndex(int[] arr){
 24         int maxIndex = 0;
 25         for(int i = 0;i <arr.length;i++){
 26             if(arr[maxIndex]<arr[i]){
 27                 maxIndex = i;
 28             }
 29         }
 30         return maxIndex;
 31     }
 32 //得到数组最小值的下标(int)
 33     public static int getMinIndex(int[] arr){
 34         int minIndex = 0;
 35         for(int i = 0;i <arr.length;i++){
 36             if(arr[minIndex]>arr[i]){
 37                 minIndex = i;
 38             }
 39         }
 40         return minIndex;
 41     }
 42 //获得数组之和(int)
 43     public static int getSum(int[] arr){
 44         int sum = 0;
 45         for(int i = 0; i < arr.length;i++){
 46             sum += arr[i];
 47         }
 48         return sum;
 49     }
 50 //获得平均值(int)
 51     public static int getAverage(int[] arr){
 52         int avg = getSum(arr)/arr.length;
 53         return avg;
 54     }
 55 //打印数组(int)
 56     public static void printArray(int[] arr){
 57         for(int i = 0;i<arr.length;i++){
 58             if(i!=arr.length-1){
 59                 System.out.print(arr[i]+",");
 60             }else{
 61                 System.out.println(arr[i]);
 62             }
 63         }
 64     }
 65 //选择排序对数据进行降序排序(int)
 66             public static void selectSortDescendingArray(int[] arr){
 67                 for(int i = 0; i<arr.length-1;i++){//i<arr.length-1;最后一个不用比较
 68                     for(int j = i+1;j<arr.length;j++){
 69                         if(arr[i]<arr[j]){
 70                             int temp = arr[j];
 71                             arr[j] = arr[i];
 72                             arr[i] = temp;
 73                          }
 74                     }
 75                 }
 76             }
 77 //选择排序对数据进行升序排序(int)
 78             public static void selectSortAscendingArray(int[] arr){
 79                 for(int i = 0; i<arr.length-1;i++){//i<arr.length-1;最后一个不用比较
 80                     for(int j = i+1;j<arr.length;j++){
 81                         if(arr[i]>arr[j]){
 82                             int temp = arr[j];
 83                             arr[j] = arr[i];
 84                             arr[i] = temp;
 85                          }
 86                     }
 87                 }
 88             }
 89 //冒泡排序对数据进行降序排序(int)
 90         public static void bubbleSortDescendingArray(int[] arr){
 91             for(int i = 0;i<arr.length-1;i++){
 92                 for(int j = 0;j<arr.length-1-i;j++){
 93                     if(arr[j]<arr[j+1]){
 94                         int temp = arr[j+1];
 95                         arr[j+1] = arr[j];
 96                         arr[j] = temp;
 97                         }
 98                 }
 99             }
100         }
101 //冒泡排序对数据进行升序排序(int)
102         public static void bubbleSortAscendingArray(int[] arr){
103             for(int i = 0;i<arr.length-1;i++){
104                 for(int j = 0;j<arr.length-1-i;j++){
105                     if(arr[j]>arr[j+1]){
106                         int temp = arr[j+1];
107                         arr[j+1] = arr[j];
108                         arr[j] = temp;
109                         }
110                 }
111             }
112         }
113 //二分查找(int)
114         public static int binarySearch(int[] arr,int key){
115             int min,mid,max;
116             min = 0;
117             max = arr.length-1;
118             while(arr[min]<arr[max]){
119                 mid = (min+max)/2;
120                 if(key>arr[mid]){
121                     min = mid+1;
122                 }else if(key<arr[mid]){
123                     max = mid-1;
124                 }else {
125                     return mid;
126                 }
127             }
128             return -1;
129         }
130 //*********************************************************************
131
132 //求数组的最大值(double)
133     public static double getMax(double[] arr){
134         double max = arr[0];
135         for(int i = 0;i<arr.length;i++){
136             if(max<arr[i]){
137                 max = arr[i];
138             }
139         }
140         return max;
141     }
142 //求数组的最小值(double)
143         public static double getMin(double[] arr){
144             double min = arr[0];
145             for(int i = 0;i<arr.length;i++){
146                 if(min>arr[i]){
147                     min = arr[i];
148                 }
149             }
150             return min;
151         }
152 //得到数组最大值的下标(double)
153         public static int getMaxIndex(double[] arr){
154             int maxIndex = 0;
155             for(int i = 0;i <arr.length;i++){
156                 if(arr[maxIndex]<arr[i]){
157                     maxIndex = i;
158                 }
159             }
160             return maxIndex;
161         }
162 //得到数组最小值的下标(double)
163         public static int getMinIndex(double[] arr){
164             int minIndex = 0;
165             for(int i = 0;i <arr.length;i++){
166                 if(arr[minIndex]>arr[i]){
167                     minIndex = i;
168                 }
169             }
170             return minIndex;
171         }
172 //获得数组之和(double)
173         public static double getSum(double[] arr){
174             double sum = 0;
175             for(int i = 0; i < arr.length;i++){
176                 sum += arr[i];
177             }
178             return sum;
179         }
180 //获得平均值(double)
181         public static double getAverage(double[] arr){
182             double avg = getSum(arr)/arr.length;
183             return avg;
184         }
185 //打印数组(double)
186                 public static void printArray(double[] arr){
187                     for(int i = 0;i<arr.length;i++){
188                         if(i!=arr.length-1){
189                             System.out.print(arr[i]+",");
190                         }else{
191                             System.out.println(arr[i]);
192                         }
193                     }
194                 }
195 //选择排序对数据进行降序排序(double)
196         public static void selectSortDescendingArray(double[] arr){
197             for(int i = 0; i<arr.length-1;i++){//i<arr.length-1;最后一个不用比较
198                 for(int j = i+1;j<arr.length;j++){
199                     if(arr[i]<arr[j]){
200                         double temp = arr[j];
201                         arr[j] = arr[i];
202                         arr[i] = temp;
203                      }
204                 }
205             }
206         }
207 //选择排序对数据进行升序排序(double)
208         public static void selectSortAscendingArray(double[] arr){
209             for(int i = 0; i<arr.length-1;i++){//i<arr.length-1;最后一个不用比较
210                 for(int j = i+1;j<arr.length;j++){
211                     if(arr[i]>arr[j]){
212                         double temp = arr[j];
213                         arr[j] = arr[i];
214                         arr[i] = temp;
215                      }
216                 }
217             }
218         }
219 //冒泡排序对数据进行降序排序(double)
220     public static void bubbleSortDescendingArray(double[] arr){
221         for(int i = 0;i<arr.length-1;i++){
222             for(int j = 0;j<arr.length-1-i;j++){
223                 if(arr[j]<arr[j+1]){
224                     double temp = arr[j+1];
225                     arr[j+1] = arr[j];
226                     arr[j] = temp;
227                     }
228             }
229         }
230     }
231 //冒泡排序对数据进行升序排序(double)
232     public static void bubbleSortAscendingArray(double[] arr){
233         for(int i = 0;i<arr.length-1;i++){
234             for(int j = 0;j<arr.length-1-i;j++){
235                 if(arr[j]>arr[j+1]){
236                     double temp = arr[j+1];
237                     arr[j+1] = arr[j];
238                     arr[j] = temp;
239                     }
240             }
241         }
242     }
243 //二分查找(double)
244             public static int binarySearch(double[] arr,double key){
245                 int min,mid,max;
246                 min = 0;
247                 max = arr.length-1;
248                 while(arr[min]<arr[max]){
249                     mid = (min+max)/2;
250                     if(key>arr[mid]){
251                         min = mid+1;
252                     }else if(key<arr[mid]){
253                         max = mid-1;
254                     }else {
255                         return mid;
256                     }
257                 }
258                 return -1;
259             }
260
261 }
时间: 2024-10-22 23:03:38

Java——int、double型数组常用操作工具类的相关文章

java属性文件properties常用操作工具类

对于java.util.Properties类,通常我们只需要做到以下3个学习目标: 1.认识properties文件,理解其含义,会正确创建properties文件. 2.会使用java.util.Properties类来操作properties文件. 3.掌握相对路径,能正确书写一个properties文件的相对路径. 而在平时的工作中,会遇到各种各样的需求,以下是一个封装. package com.herman.util; import java.io.File; import java.

2019-05-23 Java学习日记之正则表达式&amp;常用工具类

正则表达式 概述: 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串. 其实就是一种规则.有自己特殊的应用. 作用: 比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度, 这个限制长度的事情就是正则表达式做的 package com.regex; public class Demo1 { public static void main(String[] args) { // 非正则表达式实现 System.out.println(checkQQ("012345"))

Java中Collection、Map常用实现类研究分析

接口/实现类 描述 key是否可为null 为null是否报错 key是否重复 key重复是否报错 key是否和添加一致 是否线程安全 List 一组元素的集合 ArrayList 基于数组存储,读取快 是 否 是 否 是 否 LinkedList 基于双向链表存储,插入快 是 否 是 否 是 否 Vector 基于数组存储,效率较ArrayList慢 是 否 是 否 是 是 Map HashMap 是 否 否 否 否 否 TreeMap 基于红黑树实现 否 是 否 否 否 否 Concurre

字符串工具类、数组工具类、集合工具类、转型操作工具类、编码与解码操作工具类

package hjp.smart4j.framework.util; import org.apache.commons.lang3.StringUtils; /** * 字符串工具类 */ public final class StringUtil { /** * 字符串分隔符 */ public static final String SEPARATOR=String.valueOf((char)29); /** * 判断字符串是否为空 */ public static boolean i

swift -- 定义一个Double型数据的方法、数组相加、定义空字符串的方法

定义一个Double型数组的方法var arr:Array<Double> = []arr.append(9.9)var arr1 = Array<Double>()arr1.append(10.9)var arr2 = [Double]()arr2.append(7.7)var arr3 = [9.1]var arr4:Array<Double> = [8, 1] // 数组相加 var array2 = [Int](count: 5, repeatedValue:

大数据Java基础(一)int型与byte型数组的转换

为了在接下来的篇章中讲解用java实现文件的归档和解归档,需要先了解一下Java中int型与byte型数组之间的相互转换. 首先,我们先来看看int型转换成byte型数组. 我们知道,Java中,一个int型占用4个字节,一个byte型占用1个字节,所以,对于一个int型,我们需要一个长度为4的byte型数组来对其进行存储. 31位--24位 23位--16位 15位--8位 7位--0位 一个int型的4个字节如上图所示,假设用来存储的字节数组为bytes[],那么,我们可以用bytes[0]

java常用工具类(三)—— Excel 操作工具

import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.ss.usermodel.*; import org.apache.poi.xssf.usermodel.XSSFWorkbook; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; i

Java常用工具类集合

数据库连接工具类 仅仅获得连接对象 ConnDB.java package com.util; import java.sql.Connection; import java.sql.DriverManager; /** * 数据库连接工具类——仅仅获得连接对象 * */ public class ConnDB { private static Connection conn = null; private static final String DRIVER_NAME = "com.mysql

项目经验分享——Java常用工具类集合 转

http://blog.csdn.net/xyw591238/article/details/51678525 写在前面 本文涉及的工具类部分是自己编写,另一部分是在项目里收集的.工具类涉及数据库连接.格式转换.文件操作.发送邮件等等.提高开发效率,欢迎收藏与转载. 数据库连接工具类 数据库连接工具类——仅仅获得连接对象 ConnDB.java [java] package com.util; import java.sql.Connection; import java.sql.DriverM