JavaSE(一)

JavaSE(一)

1.求0—7所能组成的奇数个数

public static void main(String[] args) {
        int sum = 0;
        int count = 0;
        for(int i=1;i<=8;i++) {
            if(i==1) {
                count = 4;//1,3,5,7
            }else if(i==2) {
                count*=7;
            }else {
                count*=8;
            }
            System.out.println("0-7组成"+i+"位数时，奇数有"+count+"个");
            sum+=count;
        }
        System.out.println("一共有奇数："+sum+"个");
    }

2. 以下程序的运行结果是

switch(x){ 
case 1: 
System.out.println(1); 
case 2: 
case 3: 
System.out.println(3); 
case 4:
System.out.println(4); 
} 
当x=2时，运行结果是（C）
A 没有输出任何结果
B 输出结果为3 
C 输出结果为3和4 
D 输出结果为1、3和4

3.一个栈的入栈序列为ABCDEF，则不可能的出栈序列是 (4)

1. DEFCBA
2. DCEFBA
3. FEDCBA
4. FECDBA

4.以下哪些能够保证线程安全(A B C)

A.  单例模式
B.  java.util.Hashtable 
C.  synchronized 
D.  volatile

扩展：
1.单例模式：
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例

**2. java.util.Hashtable **

1. HashMap是非线程安全的，HashTable是线程安全的，内部的方法基本都经过synchronized修饰。

2. 因为同步、哈希性能等原因，HashMap的性能优于HashTable

3. HashMap允许有null值的存在,在HashTable不允许有null值

4. HashMap默认初始化数组的大小为16，HashTable为11。前者扩容时乘2，使用位运算取得哈希，效率高于取模。而后者为乘2加1，都是素数和奇数，这样取模哈希结果更均匀。
   **3.synchronized **
   synchronized 就是同步锁。
   使用线程同步机制（synchronized），使得在同一时间只能由一个线程修改共享数据；
   synchronized的作用主要有三个：
   原子性：确保线程互斥地访问同步代码；
   可见性：保证共享变量的修改能够及时可见，其实是通过Java内存模型中的“对一个变量unlock操作之前，必须要同步到主内存中；如果对一个变量进行lock操作，则将会清空工作内存中此变量的值，在执行引擎使用此变量前，需要重新从主内存中load操作或assign操作初始化变量值” 来保证的；
   有序性：有效解决重排序问题，即 “一个unlock操作先行发生(happen-before)于后面对同一个锁的lock操作”；
   4.volatile
   volatile是一个特征修饰符（type specifier）.volatile的作用是作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值。volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。

5.请使用二分查找算法查找字符数组{“a”,”b”,”c”,”d”,”e”,”f”,”g”,”h”}中”g”元素的位置？

    public static int search( String[] a, String v ) {
        int l, r;
        l = 0; r = a.length-1;
        while ( l <= r ) {
            int m = (l+r)/2;
            if ( a[m].compareTo(v)==0 ){
                return m;
            } else if ( a[m].compareTo(v)>0 ) {
                r = m-1;
            } else if ( a[m].compareTo(v)<0 ){
                l = m+1;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        String str[] = {"a","b","c","d","e","f","g","h"};
        int bsearch = search(str, "g");
        System.out.println(bsearch);
    }

扩展： compareTo() 方法用于将 Number 对象与方法的参数进行比较。可用于比较 Byte, Long, Integer等。

该方法用于两个相同数据类型的比较，两个不同类型的数据不能用此方法来比较。

6.用100元钱买100支笔，其中钢笔3元/支，圆珠笔2元/支，铅笔0.5元/支，问钢笔、圆珠笔和铅笔可以各买多少支？请写main方法打印需要买的数目。

  public static void main(String[] args) {
    //定义三个变量
    int x,y,z;
    //钢笔至多买100/3支
    for (x=0;x<=100/3;x++){
        //圆珠笔至多100/2
        for (y=0;y<=100/2;y++){
            //铅笔至多买100/0.5 200支 个数步进每次加2 化为 0.5*2=1
            for (z=0;z<=100*2;z+=2){
                //满足题目关系 输出一次  价钱铅笔的因为*2 还得还回来
                if (x+y+z==100 && x*3+y*2+z/2==100){
                    System.out.println("pen:"+x+", ballpoint:"+y+", pencil:"+z);
                }
            }
        }
    }

7. 随机生成一个长度200的整数数组，元素大小为1-100，统计并打印其中每个元素的重复次数

public static void main(String[] args) {
        Random random = new Random();
        int[] arr = new int[200];
        for (int i = 0; i <arr.length ; i++) {
           arr[i] =  random.nextInt(99)+1;
        }
        Map<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < arr.length; i++) {
            Integer flag = map.get(arr[i]);
            if (flag!=null){
                map.put(arr[i],flag+=1);
            }else {
                map.put(arr[i],1);
            }
        }
        System.out.println(Arrays.toString(arr));

        Set<Integer> keySet = map.keySet();
        for (Integer key : keySet) {
            System.out.println(key+"---------->个数:" + map.get(key));
        }

    }