Javase 基础中必须要掌握的19个编程

版权声明：耕种 by 会种地的DT男 https://blog.csdn.net/weixin_42617530/article/details/82048522

1.数组的逆序

public void getReverse1(int[]arr) {
    int start=0;
    int end=arr.length-1;
    for(int i=0;i<arr.length/2;i++) {
            int temp=arr[start];
            arr[start]=arr[end];
            arr[end]=temp;
            start++;
            end--;
        }
    }
public void getReverse2(int []arr) {
    for(int start=0,end=arr.length-1;start<end;start++,end--) {
        int temp=arr[start];
        arr[start]=arr[end];
        arr[end]=temp;
    }

2.数组的查找

public int search(int[]arr,int num) {
    for(int i=0;i<arr.length;i++) {
        if(num==arr[i]) {
            return i;
        }
    }
    return -1;

3.数组的遍历

public void printArr1(int [] arr) {
    for (int i : arr) {
        System.out.println(i);
    }
}
public void printArr2(int[] arr) {
    for(int i=0;i<arr.length;i++) {
        System.out.println(arr[i]);
    }
}

4.数组的最值

public void getMaxandMin0(int [] arr) {
    int max=arr[0];
    for(int i=0;i<arr.length;i++) {
        if(arr[i]>max) {
            max=arr[i];
        }
    }
    int min=arr[0];
    for(int i=0;i<arr.length;i++) {
        if(arr[i]<min) {
            min=arr[i];
        }
    }
    System.out.println("max: "+max+",min: "+min);
}
public void getMaxandMin1(int [] arr) {
    //添加到ArrayList 中, 利用lambda表达式获取最值
    ArrayList<Integer> list = new ArrayList<Integer>();
    for(int i=0;i<arr.length;i++) {
        list.add(arr[i]);
    }
    Integer max = list.stream().reduce((a,b)->(a>b?a:b)).get();
    Integer min = list.stream().reduce((a,b)->(a<b?a:b)).get();
    System.out.println("max: "+max+",min: "+min);
}
public void getMaxandMin2(int [] arr) {
    //利用Collection先排序,然后打印
    ArrayList<Integer> list = new ArrayList<Integer>();
    for(int i=0;i<arr.length;i++) {
        list.add(arr[i]);
    }
    Collections.sort(list);//默认升序排序
    System.out.println("max: "+list.get(list.size()-1)+",min: "+list.get(0));
}

5.冒泡排序

public void bubbleSort(int[] arr) {
        for(int i=0;i<arr.length-1;i++) {
            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];
                    arr[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

6.选择排序

public void selecSort(int [] arr) {
    for(int i=0;i<arr.length-1;i++) {
        for(int j=i+1;j<arr.length;j++) {
            if(arr[i]>arr[j]) {
                int temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
        }
    }
    System.out.println(Arrays.toString(arr));
}

7.二分查找

//二分查找前提是数组是有序的,所以开始需要对数组进行排序
public void binarySearch(int[] arr,int num) {
    int start=0;
    int end=arr.length-1;
    while(start<=end) {
        int middleIndex=(start+end)/2;
        int middle=arr[middleIndex];
        if(arr[0]<arr[arr.length-1]) {//判断数组为升序还是降序
            if(num==middle) {
                System.out.println(num+"所在数组中的索引是:"+middleIndex);
                return;
            }else if(num>middle) {
                start=middleIndex+1;
            }else {
                end=middleIndex-1;
            }
        }else {
            if(num==middle) {
                System.out.println(num+"所在数组中的索引是:"+middleIndex);
                return;
            }else if(num>middle) {
                end=middleIndex-1;
            }else {
                start=middleIndex+1;
            }
        }
    }
    System.out.println("对不起,数组中不存在该数");
}

8.单例设计模式的写法

//饿汉式
class Hungry{
    private static Hungry h=new Hungry();
    private Hungry() {      
    }
    public static Hungry getInstance() {
        return h;
    }
}
//懒汉式
class Lazy{
    private static Lazy l=null;
    private Lazy() {        
    }
    public static Lazy getInstance() {
        if(l==null) {
            l=new Lazy();
        }
        return l;
    }   
}

9.递归查找文件

public void searchFiles(String path,String suffix) {
    //将路径包装成File类
    File file = new File(path);
    //判断文件夹或文件
    if(file.isFile()&&(file.getAbsolutePath().toLowerCase().endsWith(suffix)) ) {//如果是文件
        System.out.println(file.getAbsolutePath());

    }else {//如果是文件夹,获取其内容
        File[] files = file.listFiles();
        if(files!=null&&files.length>0) {
            for (File f : files) {//遍历内容后 , 递归调用方法
                searchFiles(f.getAbsolutePath(), suffix);
            }
        }
    }
}

10.递归删除文件

public void deleteFiles(String path) {
    /**
     * 删除文件, java中文件夹里有内容,无法删除该文件夹, 空文件夹就是文件
     */
    //将路径包装成类, 然后判断是否为文件夹,然后删除
    File file = new File(path);
    if(file.isFile()) {
        file.delete();
    }else {
        File[] files = file.listFiles();
        if(files!=null&&files.length>0) {
            for (File f : files) {
                deleteFiles(f.getAbsolutePath());

            }
        }
        file.delete();//之后把自己删除
    }
}

11.Map的遍历

public void mapBianli(Map<Integer,String> map) {
     Set<Entry<Integer, String>> entrySet = map.entrySet();
     Iterator<Entry<Integer, String>> iterator = entrySet.iterator();
     //使用迭代器
     while(iterator.hasNext()) {
         Entry<Integer, String> next = iterator.next();
         System.out.println(next.getKey()+next.getValue());
     }
    //使用增强for循环
     for (Entry<Integer, String> entry : entrySet) {
        System.out.println(entry.getKey()+entry.getValue()); 
    }
    //利用keySet打印
    Set keySet = map.keySet();
    for (Object key : keySet) {
        System.out.println("key:"+key +", value"+map.get(key));
    }
}

12.使用迭代器完成对集合的遍历

public void iteratorList(List list) {
    Iterator it = list.iterator();
    while(it.hasNext()) {
        System.out.println(it.next());
    }
}

13.如何调用成员变量和静态变量
* 成员变量使用对象名调用
* 静态变量使用类名调用

14.如何实现定义一个接口，并实现

public interface A{
    public void show();
}
public class SubInstance implements A{
    public void show(){
        System.out.println("葫芦娃,葫芦娃,一根藤上七个瓜")
    }
}

15.匿名内部类的写法

匿名内部类指的是  实现了一个接口,或是继承了一个(抽象) 类的 子类对象;
格式:
    new 接口/(抽象)类名 ( ){重新写的方法};
    new A(){
        public void eat(){
            sysout("长生不老药何在?")
        }
    }.eat();
    或者:
    A a=new A(){
        public void eat(){
            sysout("长生不老药何在?")
    };
--------------
new A() {
    public void show() {
        System.out.println("我是卖报的小行家");
    }
}.show();

A a=new A() {

    @Override
    public void show() {
        System.out.println("我是匿名内部类的第二种书写方式 ");
    }

};

16.分别使用Comparable和Comparator实现对Person类的排序（规则自定）

public static void main(String[] args) {
        List<Person> list = new ArrayList<Person>();
        list.add(new Person("葫芦娃",10,95));
        list.add(new Person("哪吒",5,96));
        list.add(new Person("铁胆火车侠",5,93));
        list.add(new Person("藤吉少爷",9,99));

        /**
         * 使用 Comparable 对Person类进行排序 ,需要Person 类实现 Comparator<泛型 Person类型> 接口
         * 然后 方法重写, 按照实现 方式进行设计
         */
        Collections.sort(list,new  Person());
        for (Person person : list) {
            System.out.println(person);
        }
        ---------------------------------------------
        /**
         * 使用 Comparator 实现对person类的排序
         * 使用接口的匿名内部类,(list,new Comparator<Person>() {方法重写});
         */
        Collections.sort(list, new Comparator<Person>() {

            @Override
            public int compare(Person o1, Person o2) {
                //年龄升序排列,如果年龄相同,那么成绩将序排列
                if(o1.getAge()==o2.getAge()) {
                    return o2.getScore()>o1.getScore()?1:-1;
                }
                return o1.getAge()-o2.getAge();
            }
        });
        Iterator<Person> it = list.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
        ---------------------------------------------   
        //使用lambda表达式
        Collections.sort(list, (o1,o2)->{
            if(o1.getAge()==o2.getAge()) {
                return o2.getScore()>o1.getScore()?1:-1;
            }
            return o1.getAge()-o2.getAge();
        });
        Iterator<Person> it2 = list.iterator();
        while(it2.hasNext()) {
            System.out.println(it2.next());
        }

17.UDP数据的传输

    Thread thread = new Thread(client);
    Thread thread2 = new Thread(server);
    thread2.start();
    Thread.sleep(200);
    thread.start();
    ------------------------
    new Thread(new Server()).start();
    Thread.sleep(200);
    new Thread(new Client()).start();


    class Client implements Runnable{
@Override
public void run() {
    try {
        DatagramSocket ds=new DatagramSocket();
        DatagramPacket dp = new DatagramPacket("峰峦如聚,波涛如怒,山河表里潼关路".getBytes(),
                "峰峦如聚,波涛如怒,山河表里潼关路".getBytes().length , InetAddress.getLocalHost(), 8686);
        ds.send(dp);
        ds.close();

    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }           
}
}
class Server implements Runnable{


public void run() {
    try {
        DatagramSocket ds=new DatagramSocket(8686);

        DatagramPacket dp = new DatagramPacket(new byte[64*1024],64*1024);
        ds.receive(dp);
        byte[] data = dp.getData();
        int length = dp.getLength();
        InetAddress address = dp.getAddress();
        System.out.println(address.getHostAddress()+"+++"+new String(data,0,length));
        ds.close();

    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}       
}

18.TCP建立连接并传输数据（多层文件夹）

class TcpClient implements Runnable{
        public void run() {
        try {
            Socket s= new Socket("127.0.0.1", 1991);
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("c:/users/gaopu/desktop/P70621-081006-1.png"));
            BufferedOutputStream bos = new BufferedOutputStream(s.getOutputStream());
            byte[] bs=new byte[1024];
            int len;
            while((len=bis.read(bs))!=-1) {
                bos.write(bs,0,len);
            }
            bos.flush();
            bos.close();
            s.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class TcpServer implements Runnable{
public void run() {
    try {
        ServerSocket ss= new ServerSocket(1991);
        Socket s = ss.accept();
        System.out.println("已连接");
        BufferedInputStream bis = new BufferedInputStream(s.getInputStream());
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("c:/users/gaopu/desktop/拷贝副本.png"));
        byte[] bs=new byte[1024];
        int len;
        while((len=bis.read(bs))!=-1) {
            bos.write(bs,0,len);
        }
        bos.flush();
        bos.close();
        System.out.println("已接收");
        s.close();
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}       

}

19.多线程买票程序

Thread thread1 = new Thread(new Tickets(),"窗口1" );  
Thread thread2 = new Thread(new Tickets(),"窗口2" );  
Thread thread3 = new Thread(new Tickets(),"窗口3" );  
thread1.start();    
thread2.start();    
thread3.start();    

class Tickets implements Runnable{
    static int tickets=100;

public  void run() {
     ReentrantLock lock = new ReentrantLock();
        while(true) {
        lock.lock();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        if(tickets>0) {
            System.out.println("第"+Thread.currentThread().getName()+
                    "个窗口正在售第"+ tickets-- +"张票");
        }else {
            break;
        }
        lock.unlock();
    }

    }