感觉对你有用就给个鼓励吧~~

单例设计模式：

1. /**
   
2. * 单例设计模式
   
3. * 设计模式:对问题行之有效的解决方式,一种思想
   
4. * 解决的问题:就是可以保证一个类在内存中的对象唯一性
   
5. * 比如多个程序使用同一个配置信息对象时,就需要保证对象的唯一性.
   
6. * 思路:
   
7. * 1.不允许其他程序用new创建该类对象.
   
8. * 2.在该类创建一个本类实例.
   
9. * 3.提供一个方法让其他程序可以获取该对象.
   
10. * 步骤:
    
11. * 1.私有化构造函数.
    
12. * 2.通过new在本类中创建一个静态并私有本类对象.
    
13. * 3.定义一个公有的静态方法,将创建的对象返回.
    
14. */
    
15. //饿汉式--直接用
    
16. class Single_Hungry{
    
17.         private Single_Hungry(){}
    
18.         static private Single_Hungry sh = new Single_Hungry();
    
19.         public static Single_Hungry getInstance(){
    
20.                 return sh;
    
21.         }
    
22. }
    
23. //懒汉式--先null
    
24. class Single_Lazy{
    
25.         private Single_Lazy(){}
    
26.         private static  Single_Lazy sl = null;
    
27.         public static Single_Lazy getInstance(){
    
28.                 if(sl==null){
    
29.                         sl =new Single_Lazy();
    
30.                 }
    
31.                 return sl;
    
32.         }
    
33. }
    
34. 
    
35. public class SingleDemo {
    
36. 
    
37.         public static void main(String[] args) {
    
38.                 Single_Hungry sh1 = Single_Hungry.getInstance();
    
39.                 Single_Hungry sh2 = Single_Hungry.getInstance();
    
40.                 System.out.println(sh1.equals(sh2));
    
41.                 Single_Lazy sl1 = Single_Lazy.getInstance();
    
42.                 Single_Lazy sl2 = Single_Lazy.getInstance();
    
43.                 System.out.println(sl1.equals(sl2));
    
44.         }
    
45. }
    

复制代码

输出结果：

true
true


数组工具类：

1. /**
   
2. * 数组工具
   
3. * @author maidou51
   
4. * @version v1.0
   
5. */
   
6. class ArrayTool {
   
7.         //该类中的方法都是静态的,所以该类时不需要创造对象的
   
8.         //未来保证不让他人创建对象,可以将构造函数私有化
   
9.         private ArrayTool(){}
   
10.         /**
    
11.          * 获取整型数组的最大值
    
12.          * @param arr 接收一个元素为int 类型的数组
    
13.          * @return 该数组的最大的元素值
    
14.          * */
    
15.         //获取整形数组的最大值
    
16.         public static int getMax(int[] arr){
    
17.                 int maxIndex = 0;
    
18.                 for (int i = 0; i < arr.length; i++) {
    
19.                         if(arr[i]>arr[maxIndex]){
    
20.                                 maxIndex = i;
    
21.                         }
    
22.                 }
    
23.                 return arr[maxIndex];
    
24.         }
    
25.         /**
    
26.          * 对数组进行选择排序
    
27.          * @param arr接收一个元素为int的数组
    
28.          * */
    
29.         //对数组进行选择排序
    
30.         public static void selectSort(int[] arr){
    
31.                 for (int i = 0; i < arr.length-1; i++) {
    
32.                         for (int j = i+1; j < arr.length; j++) {
    
33.                                 if(arr[i]>arr[j]){
    
34.                                         swap(arr,i,j);
    
35.                                 }
    
36.                         }
    
37.                 }
    
38.         }
    
39.         //用于给数组进行元素的位置置换.
    
40.         private static void swap(int[] arr, int i ,int j){
    
41.                 int temp = arr[i];
    
42.                 arr[i] = arr[j];
    
43.                 arr[j] = temp;
    
44.         }
    
45.         /**
    
46.          * 获取指定的元素在指定数组中的索引
    
47.          * @param arr 接收一个元素为int 类型的素组
    
48.          * @param key 要找的元素
    
49.          * @return 返回该元素第一次出现的位置,如果不存在则返回-1
    
50.          * */
    
51.         //获取指定的元素在指定数组中的索引
    
52.         public static int getIndex(int[] arr,int key){
    
53.                 for (int i = 0; i < arr.length; i++) {
    
54.                         if(arr[i]==key){
    
55.                                 return i;
    
56.                         }
    
57.                 }
    
58.                 return -1;
    
59.         }
    
60.         /**
    
61.          * 将int素组转换陈字符串,格式是:[e1,e2...]
    
62.          * @param arr 接收一个元素为int 类型的数组
    
63.          * @return 返回该数组的字符串表现形式
    
64.          * */
    
65.         //将int数组转换字符串,格式是:[e1,e2...]
    
66.         public static String arrayToString(int[] arr){
    
67.                 String str = "[";
    
68.                 for (int i = 0; i < arr.length; i++) {
    
69.                         if(i !=arr.length-1){
    
70.                                 str = str + arr[i]+",";
    
71.                         }else{
    
72.                                 str = str +arr[i]+"]";
    
73.                         }
    
74.                 }
    
75.                 return str;
    
76.         }
    
77. }
    
78. public class ArrayToolDemo {
    
79.         //保证程序的独立运行
    
80.         public static void main(String[] args) {
    
81.                 int[] arr = {1,2,5,8,6,3,34};
    
82.                 int max = ArrayTool.getMax(arr);
    
83.                 System.out.println("max="+max);
    
84.                 int index = ArrayTool.getIndex(arr, 3);
    
85.                 System.out.println("index="+index);
    
86.         }
    
87. }

复制代码

运行结果：

max=34
index=5

感觉对你有用就给个鼓励吧~~

自己的帖子自己顶！d=====(￣▽￣*)b!!希望更多小伙伴看到~

赞一下