例题知识点

1.冒泡排序

//每一次循环都把最大的数直接固定在最后一位,相邻的对比大的交换到后面

public static int[] bubbleSort ( int[] array ){

//外循环控制循环次数,

public static int[] bubbleSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            //-1 角标建议防止越界
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int max = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = max;
                }
            }
        }
        return array;
    }

2.对象创造

public class Demo {
            public static void main(String[] args) {
                Demo d = new Demo();
                d.first();
            }
            public void first() {
                int i = 5;
                value v = new value();
                v.i = 25;
                second(v, i);
                System.out.println(v.i);
            }
            public void second(value v, int i) {
                i = 0;
                v.i = 20;
                value val = new value();
                v = val;
                System.out.println(v.i + " " + i);
            }
        }
        class value {
            int i = 15;
        }

结果:15 0
20

3.switch 语句;

1. 在switch只认break,以及return 以及switch的结束分号,要不然仍然继续执行.
   
2. 当case条件满足时: 没有发现break,会从当前case ,后面所有的case值都会输出 ,直到找到break, 没有的话就执行到switch结束的结束分号}
   
3. default放在末尾只会case条件不符合,或者case语句没有找到break才会执行.
   
4. default放在中间只有没有符合条件case的才会执行,有的话就不会执行了,如果他也没有break,就会和2一样,继续执行.
   

int a = 5;
        switch (a) {
            case 1:
                System.out.println(1);
            default:
                System.out.println("default");
            case 2:
                System.out.println(2);
            case 3:
                System.out.println(3);
            case 4:
                System.out.println(4);
        }
        //输出:default 2 3 4
        int a = 3;
        switch (a) {
            case 1:
                System.out.println(1);
            default:
                System.out.println("default");
            case 2:
                System.out.println(2);
            case 3:
                System.out.println(3);
            case 4:
                System.out.println(4);
        }
        // 输出:3 4

4.equals和” == “的区别,以及创造String对象的对比

==
可以使用在基本类型和引用数据之间
基本数据类型就是比较两个变量保存的数据是否相等.(类型可以不相同)
引用类型就是比较两个对象的地址值是否相等,指向同一个对象实体

equals只能用于引用类型
object的equals的比较也是地址值与==相同;
有类重写方法所以可以比较内容

注意String str3 = new String(“abcd”)的实现过程：直接在堆中创建对象,堆中指向常量值,常量池没有就创建一个.
而 String str1 = “abcd”的实现过程：首先栈区创建str引用，然后在String池（独立于栈和堆而存在，存储不可变量）中寻找其指向的内容为”abcd”的对象，如果String池中没有，则创建一个，然后str指向String池中的对象，如果有，则直接将str1指向”abcd””;

String str1 = "abcd" ;
String str2="abcd"  ;
str1 == str2  (true) ;
String str1 = new String("abcd"); 
String str2 = new String("abcd")
str1.equals(str2) true  //String 重写了equals方法
str1== str2(false) //str1和str2都是装的堆当中的地址值
String s1 = "aaa";
String s2 = "bbb";
String s3 = "aaabbb";
String s4 = "aaa"+"bbb";  s3==s4 (true)
String s5 = s1+"bbb"; s3==s5 (false) 
String s6 = "aaa"+s1; s3 =s6 (false)
String s7 = s1+s2 ; s1==s7(false)
final Strting s9 = s1+"bbb";
(s3==s9) true, (fianl就是常量)
s7 == s6(false)
String s8 = s5.intern(); s8==s3(true)

• 常量与常量,结果都在常量池,常量池不会存在相同的常量
  * 只要有一个变量,结果就在队中
  intern(); 对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。

5.自动装箱的问题

Object o = true ; ? new Integer(1) : new Double(2.0); 
System.out.println(ol) 
结果1.0 
Integer i = new Integer(1) ; 
Integer j = new Integer(1);    
System,out.println( i==j )  //false

Integer内部定义了IntegerCache结构integer[],保存了-128~127范围内,使用自动装箱,可以直接使用数组中的元素,不用再去new.

Integer m = 1 ;
Integer n = 1 ; 
System.out.println( m==n ) ; //true 
Integer x = 128 ; 
Integer y =128 ; 
System.out.println(x==y) ;  //false ; 
double f = 1.2;
Double z = 1.2 ;
System.out.println(f==z); //true

6.重写equals案例

class test {
            int x;
            String y;
            public test(int x, String y) {
                this.x = x;
                this.y = y;
            }
            @Override
            public boolean equals(Object obj) {
                if (this == obj) {
                    return true;
                }
                if (obj instanceof test) {
                    test t = (test) obj;
                    if (this.x == t.x && this.y.equals(t.y)) {
                        return true;
                    }
                    return false;
                }
                return false;
            }
        }

7.代码块和一些静态代码块的执行

public class Demo {
            @Test
            public void show() {
                new Leaf();
            }
        }
        class Root {
            static {
                System.out.println("Rooot静态代码块");
            }
            {
                System.out.println("Root普通代码块");
            }
            public Root() {
                System.out.println("Root的无参构造器");
            }
        }
        class Mid extends Root {
            static {
                System.out.println("Mid静态代码块");
            }
            {
                System.out.println("Mid普通代码块");
            }
            public Mid() {
                System.out.println("Mid的无参构造器");
            }
            public Mid(String msg) {
                System.out.println("Mid的带参构造器" + msg);
            }
        }
        class Leaf extends Mid {
            static {
                System.out.println("Leaf静态代码块");
            }
            {
                System.out.println("Leaf普通代码块");
            }
            public Leaf() {
                super("666");
                System.out.println("Leaf的带参构造器");
            }
        }

输出结果
Rooot静态代码块
Mid静态代码块
Leaf静态代码块
Root普通代码块
Root的无参构造器
Mid普通代码块
Mid的带参构造器666
Leaf普通代码块
Leaf的带参构造器

8.Java静态代码块、构造代码块、构造方法的执行顺序

静态代码优先于非静态的代码，是因为被static修饰的成员都是类成员，会随着JVM加载类的时候加载而执行，而没有被static修饰的成员也被称为实例成员，需要创建对象才会随之加载到堆内存。所以静态的会优先非静态的。
执行构造器（构造方法）的时候，在执行方法体之前存在隐式三步：
1，super语句，可能出现以下三种情况：
1）构造方法体的第一行是this语句，则不会执行隐式三步，
2）构造方法体的第一行是super语句，则调用相应的父类的构造方法，
3）构造方法体的第一行既不是this语句也不是super语句，则隐式调用super()，即其父类的默认构造方法，这也是为什么一个父类通常要提供默认构造方法的原因；
2，初始化非静态变量；
3，构造代码块。
由此可知，构造代码块优先于构造方法的方法体，但是this关键字跟super关键字不能同时出现，而且只能在代码的第一行。如果出现了this关键字，隐式三步就不会执行。
例如，分析下面的代码及执行结果，已经用注释标出了执行步骤Step 1–Step 7。
// 重点 也就是说，当递归调用多个构造方法的时候，构造代码块只会在最后的（也即方法体第一行不是this语句的）那个构造方法执行之前执行！

public class Test {
    public static int a = 0;
    static {
        // Step 1
        a = 10;
        System.out.println("静态代码块在执行a=" + a);
    }
    {
        // Step 4
        a = 8;
        System.out.println("非静态代码块（构造代码块）在执行a=" + a);
    }
    public Test() {
        this("调用带参构造方法1，a=" + a);// Step 2
        System.out.println("无参构造方法在执行a=" + a);// Step 7
    }
    public Test(String n) {
        this(n, "调用带参构造方法2，a=" + a); // Step 3
        System.out.println("带参构造方法1在执行a=" + a);// Step 6
    }
    public Test(String s1, String s2) {
        System.out.println(s1 + "；" + s2); // Step 5   
    }
    public static void main(String[] args) {
        Test t = null;
        System.out.println("下面new一个Test实例：");
        t = new Test();
    }
}

执行结果：
静态代码块在执行a=10
下面new一个Test实例：
非静态代码块（构造代码块）在执行a=8
调用带参构造方法1，a=10；调用带参构造方法2，a=10
带参构造方法1在执行a=8

9.接口

interface A {
    int x = 0;
}
class B {
    int x = 1;
}
class C extends B implements A {
    public void show() {
        System.out.println(x); //编译不通过x不明确         System.out.println(super.x) 
        // 输出1    
        System.out.println(A.x);
        //输出0 
    }
    public static void main(String[] args) {
        new c().show();
    }
}

10.线程安全的案例

继承Thread类的安全问题解决方案

import java.util.ArrayList;
import java.util.concurrent.locks.ReentrantLock;
package com.adong.java;
public class Demo01 {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}
//方法一
class MyThread extends Thread {
    private static int ticket = 100;
    @Override
    public void run() {
        while (true) {
            synchronized (MyThread.class) { //方法一
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + " : " + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
//方法二
class MyThread extends Thread {
    private static int ticket = 100;
    @Override
    public void run() {
        while (true) {
            show();
        }
    }
    public static synchronized void show() {
        //监视器:MyThread.class
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + ticket);
            ticket--;
        }
    }
}
// 实现Runnable的线程安全的解决方案
public class Demo01 {
    public static void main(String[] args) {
        Mythread t = new Mythread();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        t1.start();
        t2.start();
        t3.start();
    }
}
//方法一
class Mythread implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                //方法一
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + " : " + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
} //方法二
class Mythread implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        while (true) (show();
    }
    private synchronized void show() {
        //方法二监视器就是this
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + ticket);
            ticket--;
        }
    }
} //方法三
class Mythread implements Runnable {
    private int ticket = 100;
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                //加上锁
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + " : " + ticket);
                    ticket--;
                } else {
                    break;
                }
            } finally {
                lock.unlock(); //解锁
            }
        }
    }
}
//方法内部类常见方法
public class Demo {
    public Comparable getComparable1() {
        // 方法一
        class MyComparable1 implements Comparable {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }
        return new MyComparable1();
    }
    public Comparable getComparable2() {
        // 方法二
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }
}

12.死锁案例

public class deadlockDemo {
    public static Object object1 = new Object();
    public static Object object2 = new Object();

    public static void main(String[] args) {
        look1 l1 = new look1();
        look2 l2 = new look2();
        Thread t1 = new Thread(l1);
        Thread t2 = new Thread(l2);
        t1.start();
        t2.start();
    }
}

class look1 implements Runnable {
    @Override
    public void run() {
        System.out.println("look1 run");
        while (true) {
            synchronized (deadlockDemo.object1) { //拥有object1这个锁           
                System.out.println("look1 have object1");
                try {
                    Thread.sleep(100); //睡眠让look2有机会执行并让他获得object2锁     
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }                 //此时需要object2锁,才能继续执行,因为object1还没有被look1释放,而look2拥有object2,需要object1才能释放object2          
                synchronized (deadlockDemo.object2) {
                    System.out.println("look1 have object2");
                }
            }
        }
    }
}

class look2 implements Runnable {
    @Override
    public void run() {
        System.out.println("look2 run");
        synchronized (deadlockDemo.object2) {
            System.out.println("look2 have object2");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (deadlockDemo.object1) {
                System.out.println("look2 have object1");
            }
        }
    }
}

13.线程通信的案例

不断输入.等待输出了,才会在去输出

public class Demo01 {
    public static void main(String[] args) {
        person p = new person();
        Input input = new Input(p);
        Output output = new Output(p);
        Thread t1 = new Thread(input);
        Thread t2 = new Thread(output);
        t1.start();
        t2.start();
    }
}
class person {
    private String name;
    private String gender;
    boolean flag;
    //设置同步方法,让输入和输出只能有一个方法执行
    public synchronized void set(String name, String gender) {
        //判断是否有值,有值就为true,就让他等待
        if (flag) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //没值就执行下面的代码赋值,并去激活输出线程
        this.name = name;
        this.gender = gender;
        flag = true;
        notify();
    }
    public synchronized void get() {
        //为!flag表示为true是就去执行下面语句并去唤醒输入线程,false就等待输入线程传值
        if (!flag) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(name + ":" + gender);
        flag = false; //
        notify(); //激活输入线程
    }
}
class Input implements Runnable {
    private person p;
    public Input(person p) {
        this.p = p;
    }
    @Override
    public void run() {
        int x = 0;
        while (true) {
            if (x == 0) {
                p.set("kkkk", "男男");
            } else {
                p.set("TTTT", "女女");
            }
            x = (x + 1) % 2;
        }
    }
}
class Output implements Runnable {
    private person p;
    public Output(person p) {
        this.p = p;
    }
    @Override
    public void run() {
        while (true) {
            p.get();
        }
    }
}

运行:
kkkk:男男
TTTT:女女
kkkk:男男
TTTT:女女
…省略

13.消费者和生产者

14.你真的懂i++和++i 吗

int i = 0;
i = i++;
System.out.println("i = " + i); //0

示例2
int a = 2;
int b = (3 * a++) + a;
System.out.println(b);  //9
示例3
int a = 2;
int b = a + (3 * a++);
System.out.println(b); // 8
示例4
int i = 1;
int j = 1;
int k = i++ + ++i + ++j + j++;
System.out.println(k); // 8
示例5
int a = 0;
int b = 0;
a = a++; 
b = a++;
System.out.println("a = " + a + ", b = " + b); // a=1 , b = 0 ;

你始终记住一点就是
int temp = i;
i = i + 1;
return temp; 这3句代码就是上面所说的那样：i++是先自增，然后才返回自增之前的值。
++i 即前加加，原理是：先自增，然后返回自增后的值
i++ 即后加加，原理是：先自增，然后返回自增之前的值
https://blog.csdn.net/android_cai_niao/article/details/106027313

15:这就是set

public class CollectionDemo {
    @Test
    public void show() {
        Person p1 = new Person("aaa", "11");
        Person p2 = new Person("bbb", "20");
        Set set = new HashSet();
        set.add(p1);
        set.add(p2);
        System.out.println(set.toString());//[Person{name='aaa', age='11'}, Person{name='bbb', age='20'}]
        p1.name = "xxx";//值虽然改了,但是还是把他存在"aaa","11"所计算的hashcode的位置
        set.remove(p1);//删除hashcode为"xxx","11"对象;此时p1以前hashcode为"aaa","111";所以没有找到.
        System.out.println(set.toString());//[Person{name='xxx', age='11'}, Person{name='bbb', age='20'}]
        set.add(new Person("xxx", "11"));//添加到"xxx","11'的位置
        System.out.println(set.toString());//[Person{name='xxx', age='11'}, Person{name='xxx', age='11'}, Person{name='bbb', age='20'}]
        set.add(new Person("aaa", "11"));//p1存放的时"aaa","11"哈希值存放位置,所以判断他们相等,比较equals是p1已经是"xxx","11",他们不相等,所以也添加成功,通过链表存储时p1指向新的
        System.out.println(set.toString());//[Person{name='xxx', age='11'}, Person{name='xxx', age='11'}, Person{name='bbb', age='20'}, Person{name='aaa', age='11'}]
    }
}

class Person {
    String name;
    String age;

    public Person() {
    }

    public Person(String name, String age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        if (name != null ? !name.equals(person.name) : person.name != null) return false;
        return age != null ? age.equals(person.age) : person.age == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + (age != null ? age.hashCode() : 0);
        return result;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }
}

16.tcp连接例题

importorg.junit.Test;

importjava.io.ByteArrayOutputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;
importjava.net.InetAddress;
importjava.net.ServerSocket;
importjava.net.Socket;
/**
*@authoradong
*/
public classTcpTest {
//客户端
@Test
public voidclient() {
Socket socket =null;
OutputStream is =null;
try{
//指明服务器端的ip
InetAddress inet = InetAddress.getByName(“192.168.3.11”);
//创建socket对象,指定端口号
socket =newSocket(inet,8899);
//获取输出流,输出数据
is = socket.getOutputStream();
//写入数据
is.write(“小白船”.getBytes());
}catch(IOException e) {
e.printStackTrace();
}finally{
//资源关闭
if(is !=null) {
try{
is.close();
}catch(IOException e) {
e.printStackTrace();
}
}
if(socket !=null) {
try{
socket.close();
}catch(IOException e) {
e.printStackTrace();
}
}

        }<br />    }

//服务端<br />    @Test<br />    public voidserver() {<br />        ServerSocket ss =null;<br />        Socket socket =null;<br />        InputStream inputStream =null;<br />        ByteArrayOutputStream bois =null;<br />        try{<br />            //创建severSocket对象,指明端口号<br />            ss =newServerSocket(8899);<br />            //调用accept()接收客户端的Socket<br />            socket = ss.accept();<br />            //获取输入流,读取socket中的数据<br />            inputStream = socket.getInputStream();<br />            //读取输入流中的数据<br />            bois =newByteArrayOutputStream();<br />            byte[] bytes =new byte[10];<br />            intlen;<br />            while((len = inputStream.read(bytes)) != -1) {<br />                bois.write(bytes,0,len);<br />            }<br />            System._out_.println(bois.toString());<br />        }catch(IOException e) {<br />            e.printStackTrace();<br />        }finally{<br />            //关闭资源<br />            if(bois !=null) {<br />                try{<br />                    bois.close();<br />                }catch(IOException e) {<br />                    e.printStackTrace();<br />                }<br />            }<br />            if(inputStream !=null) {<br />                try{<br />                    inputStream.close();<br />                }catch(IOException e) {<br />                    e.printStackTrace();<br />                }<br />            }<br />            if(socket !=null) {<br />                try{<br />                    socket.close();<br />                }catch(IOException e) {<br />                    e.printStackTrace();<br />                }<br />            }<br />            if(ss !=null) {<br />                try{<br />                    ss.close();<br />                }catch(IOException e) {<br />                    e.printStackTrace();<br />                }<br />            }<br />       }<br />    }<br />}

17.UDPD的例题

public class UDPTest {
    //发送端
    @Test
    public void sender() throws IOException {
        //建立udp的socket服务
        DatagramSocket socket = new DatagramSocket();
        //发送的内容        
        String str = "我是UDP方式发送的导弹";
        byte[] data = str.getBytes();
        InetAddress inet = InetAddress.getLocalHost();
        //将要发送的数据封装到数据包中 
        DatagramPacket packet = new DatagramPacket(data, 0, data.length, inet, 9090);
        //通过udp的socket服务将数据包发送出去      
        socket.send(packet);
        // 关闭服务      
        socket.close();
    }

    //接收端
    @Test
    public void receiver() throws IOException {
        //建立udp socket服务 
        DatagramSocket socket = new DatagramSocket(9090);
        byte[] buffer = new byte[100];
        // 创建数据包,用于存储接受到的数据.方便数据包对对象的方法解析这些数据   
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
        // 使用socket服务的receive方法去接收数据存储到数据包中      
        socket.receive(packet);
        System.out.println(new String(packet.getData(), 0, packet.getLength()));
        // 关闭资源         
        socket.close();
        // 
    }
}

URL练习(下载图片)

public class URLTest1 {
    public static void main(String[] args) {
        HttpURLConnection urlConnection = null;
        InputStream is = null;
        FileOutputStream fos = null;
        try {
            URL url = new URL("http://localhost:8080/examples/beauty.jpg");
            urlConnection = (HttpURLConnection) url.openConnection();
            urlConnection.connect();
            is = urlConnection.getInputStream();
            fos = new FileOutputStream("day10\\beauty3.jpg");
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }
            System.out.println("下载完成");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
        }
    }
}