CodePanda@GPF
CodePanda@GPF

Java基础疑难点梳理(泛型到反射9章内容)

文章目录

  • 1. 泛型
  • 2. 基础类库
  • 3. 集合
  • 4. 异常
  • 5. 注解
  • 6. JDBC
  • 7. IO流
  • 8. 网络编程
  • 9. 类加载和反射

1. 泛型

  1. 静态方法的形参，静态变量，静态代码块中不能使用泛型（因为即使泛型不同，还是同一个类，静态变量是属于类的）

  2. instanceof运算符后不能跟泛型类：a instanceof ArrayList

  3. A extends B A[]是B[]的子类 但是List 不是List的子类

  4. 通配符的使用

    public static void main(String[] args) {
        List<Integer> integers = new ArrayList<>();
        //f1(integers); 不能调用 List 不是 List list子类
        f2(integers);//可以使用通配符调用
    }
    public static void f1(List<Object> list){
        for (Object o : list) {
            System.out.println(o);
        }
        list.add("123");
        list.add(123);
    }
    public static void f2(List<?> list){
        for (Object o : list) {
            System.out.println(o);
        }
        //不能添加元素 因为不知道?是什么类型
        //list.add("123"); 如果?是Integer类型呢
       // list.add(123); 如果?是String类型呢
        //只能添加null
        list.add(null);//可以添加null 因为null是所有类的子类
    }


      

    • ? 普通通配符：可以匹配所有的泛型，不能添加元素（除了null）
      • 

    • ？extends A 上限通配符：可以匹配A以及A的子类的泛型，不能添加元素（除了null）
      • 

    • ？super A 下限通配符：可以匹配A以及A的父类的泛型,可以添加A类型对象和null
      • 

     
    class A{

}
class A1 extends A{

}
class A2 extends A{

}
 public static void main(String[] args) {
       List<A> list1=new ArrayList<>();
       f1(list1);//ok
       f2(list1);//ok
       f3(list1);//ok

        List<A2> list2=new ArrayList<>();
        f1(list2);//ok
        f2(list2);//ok
        f3(list2);//not ok A2不是A1的子类
    }
//f1 f2 f3不构成参数重载 函数名必须不同
    public static void f1(List<?> list){

    }
    public static void f2(List<? extends A> list){

    }
    public static void f3(List<? super A1> list){

    }

     

  5.  
    上下限的设置不仅仅可以配合?一起使用，也可以单独作为类的泛型界限
     
    class A <T extends Number>{
    T a;
}

     
    6. 

  6.  
    关于泛型类（接口的继承）
     
    class A <T>{
}
class A1 extends A<String>{
}
class A2<T> extends A{//A2是子类中的新的泛型 与A无关 A中的泛型默认是Object
}
class A3<T> extends A<T>{//A2中的T和A相同  继承了T
}
class A4<T,E> extends A<T>{//继承了T并且拓展了泛型E
}
//class A5 extends A{
//}
//class A6 extends A{
//}

     
    7. 

  7.  
    泛型方法
     
     	public static void main(String[] args) {
        Integer f = f(new ArrayList<Integer>(), 12);
        Double f1 = f(new ArrayList<String>(), 1.2);
    }
    public static <T,E>  E f(List<T> list,E value){
        return  value;
    }
	//泛型方法中的形参也可以和？一起使用
 	public static <T> void f2(List<? extends T> list){
        
    }

    

      

    • 泛型方法一般可以替代通配符？
      • 

    • 泛型方法一般用于参数之间具有依赖性或者参数与返回值之间有依赖性的情况
      • 

     
    public static void main(String[] args) {
        ArrayList<Integer> src = new ArrayList<>();
        src.add(1);
        src.add(2);
        ArrayList<Integer> dest = new ArrayList<>();
        copy(src,dest);
    }
//参数互相依赖
public static <T>  void copy(List<T> src,List<T> dest){
    for (int i = 0; i < src.size(); i++) {
        dest.add(src.get(i));
    }
}
public static  void f2(List<?> src,List<?> dest){
    for (int i = 0; i < src.size(); i++) {
       // dest.add(src.get(i)); dest的类型是？ 只能往里面添加null
    }
}
//参数与返回值依赖
public static <T>  T f(List<T> list){
    return list.get(0);
}

     
    8. 

  8.  
    构造器泛型和菱形语法失效
     
    class A {
public <T> A(T x){
    System.out.println(x);
}
}
public static void main(String[] args) {
 //构造器泛型
    new A(123);
    new A("1.23");
}

     
    class A<E> {
    public <T> A(T x){
        System.out.println(x);
    }
}
 public static void main(String[] args) {
        A<String> a1=new A<>(123);
       // A a2=new A(123); 显示指定了泛型构造器中的形参类型
 }

     
    9. 

  9.  
    泛型擦除
    

      

    1. 具有泛型信息的对象赋值给一个没有泛型信息的的变量时会发生泛型擦除
      2. 

     
    public static void main(String[] args) {
        List<Integer> list1=new ArrayList<>();
    	list1.add("123");//not ok
        List list2=list1;//泛型擦除 
    	list2.add("123");// ok
        List list3=new ArrayList();//不带泛型的对象赋值给一个带泛型的变量-->"堆污染"
        List<Integer> list4=list3;//list4只能添加Integer元素
    }

     
    10. 

  10.  
    没有泛型数组
    

      

    • 泛型信息只在编译期间有，在运行期间是没有的
      • 

    • 不管是List List List在运行期间都是List
      • 

     
    //java数组存在型变的问题：A是B的子类 A[]也是B[]的子类 可以向上转型
Integer[] a=new Integer[2];
Object[] b=a;
b[0]="hello";//编译ok 运行期间错误

//由于上面的型变问题，假设可以创建泛型数组
List<Integer>[] a=new ArrayList<Integer>[2];//编译ok(假设可以创建泛型数组)
Object[] b=a;//ok
a[1]=new ArrayList<String>();//运行期间错误 
//所以不能创建泛型数组

//此外
T a=new T[2];//这种方式也不行
//数组的创建在运行期间，泛型信息在运行期间没有，所以不知道创建什么类型的数组

//ps:这样的创建数组是可以的 即不给ArrayList添加泛型
List<Integer>[] a=new ArrayList[2];
a[0]=new ArrayList<Integer>();
a[1]=new ArrayList<Integer>();
//a[1]=new ArrayList(); not ok
a[1].add("123");//not ok 引用类型的泛型限制
a[1].add(123);//ok
//或者
List[] a=new ArrayList[2];
a[0]=new ArrayList<Integer>();
a[0].add("123");//上面的Integer泛型失效 因为引用类型的泛型是Object 所以可以添加"123"
a[0].add(123);
a[1]=new ArrayList<String>();
a[1].add("123");//ok
a[1].add(123);//ok

     
    11. 


    

    2. 基础类库
    

      

    1.  
      Scanner可以读键盘输入、也可以读取文件
      

        

      • next以空格为分隔符读取
        • 

      • nextLine以换行符为分隔符读取
        • 

      • 可以指定分隔符：scanner.useDelimiter("\n");
        • 

      • 读键盘：Scanner scanner=new Scanner(System.in);
        • 

      • 读文件：Scanner scanner = new Scanner(new File("data.txt"));
        • 

       
      2. 

    2.  
      System类
       
       public static void main(String[] args) throws FileNotFoundException {
        /**
         * getenv:获取系统变量
         * getProperties: 获取系统属性值
         */
        System.out.println(System.getenv("JAVA_HOME"));
        System.out.println(System.getProperty("os.name"));
        Map<String, String> env = System.getenv();//获取所有环境变量
        for (String s : env.keySet()) {
            System.out.println(s+"--->"+env.get(s));
        }
        Properties properties = System.getProperties();//获取系统所有的属性值
        System.out.println(properties);

        /**
         * 获取毫秒和纳秒时间戳
         */
        System.out.println(System.currentTimeMillis());//获取当前时间戳ms
        System.out.println(System.nanoTime());//获取当前时间戳ns

        /**
         * identityHashCode：唯一标识对象
         * 值相同则说明两个对象的地址相同 是同一个对象
         */
        Object o1 = new Object();
        Object o2 = new Object();
        System.out.println(System.identityHashCode(o1));//460141958
        System.out.println(System.identityHashCode(o2));//460141958

        String s1=new String("hello");
        String s2=new String("hello");
        System.out.println(System.identityHashCode(s1));//460141958
        System.out.println(System.identityHashCode(s2));//356573597

        String s3="hello";
        String s4="hello";
        System.out.println(System.identityHashCode(s3));//1735600054
        System.out.println(System.identityHashCode(s4));//1735600054
    }

       
      3. 

    3.  
      Runtime类
       
       public static void main(String[] args) throws IOException {
        Runtime runtime = Runtime.getRuntime();
        System.out.println(runtime.availableProcessors());//可用cpu核数
        System.out.println(runtime.freeMemory());//空闲jvm内存 单位字节
        System.out.println(runtime.maxMemory());//最大jvm内存
        runtime.exec("notepad.exe");//打开记事本
    }

       
      4. 

    4.  
      Object类
      

        

      • boolean equals(Object obj)
        • 

      • protected void finalize()
        • 

      • Class getClass()
        • 

      • int hashCode()
        • 

      • String toString()
        • 

      • wait()
        • 

      • notify()
        • 

      • notifyAll()
        • 

      • protected native clone():本地方法，自定义的类可以实现Cloneable接口实现克隆（对于引用类型是浅拷贝）
        • 

       
      class Person implements Cloneable{
    String name;
    Pet pet;
    @Override
    protected Person clone() throws CloneNotSupportedException {
        return (Person) super.clone();
    }

    public Person(String name, Pet pet) {
        this.name = name;
        this.pet = pet;
    }
}
class Pet{
    String name;
    public Pet(String name) {
        this.name = name;
    }
}
 public static void main(String[] args) throws IOException, CloneNotSupportedException {

        Person p1 = new Person("tom",new Pet("dog"));
        Person p2=p1.clone();
        /**
         * clone是浅拷贝
         * Pet这个引用类型的变量只是拷贝了引用
         */
        System.out.println(p1==p2);//false
        System.out.println(p1.pet==p2.pet);//true
    }

//如何修改为深拷贝？
//1. 给Pet类也实现 clone()方法
@Override
protected Pet clone() throws CloneNotSupportedException {
    return (Pet) super.clone();
}
//2. 修改Person类的clone方法如下
 @Override
protected Person clone() throws CloneNotSupportedException {
    Person p=(Person) super.clone();
    p.pet=pet.clone();
    return p;
}

       
      5. 

    

    

    3. 集合
    

      

    1.  
      集合转化为数组
       
      Integer[] arr= new Integer[list.size()];//不能是int[] 必须是Integer[]
arr=list.toArray(arr);
System.out.println(Arrays.toString(arr));

Object[] arr2=list.toArray();//这种方式只能返回Object[]类型的数组
System.out.println(Arrays.toString(arr2));

       
      2. 

    2.  
      集合框架
      

        

      1.  
        Collection接口
        

          

        • List

            

          • ArrayList
            • 

          • LinkedList
            • 

           
          • 

        • Set

            

          • HashSet(无序指的是元素按照hashCode值排列的，输出时的序列是固定的)

              

            • LinkedHashSet（有序指的是按照元素输出是按添加顺序排列的）
              • 

             
            • 

          • SortedSet

              

            • TreeSet（判断对象是否相同是根据compareTo方法，而不是hashCode方法）(不能添加null,因为需要排序)
              • 

             
            • 

           
          • 

        • Queue

            

          • PriorityQueue(不能添加null,因为需要排序)
            • 

          • ArrayDeque(常用做栈)
            • 

           
          • 

         
        2. 

      2.  
        Map接口
        

          

        • HashMap

            

          • LinkedHashMap
            • 

           
          • 

        • SortedMap

            

          • TreeMap(不能添加null,因为需要排序)
            • 

           
          • 

         
        3. 

      3.  
        Lambda表达式遍历集合
         
        list.forEach(new Consumer<Integer>() {
    @Override
    public void accept(Integer integer) {
       System.out.print(integer);//lambda的本质：匿名内部类
    }
});
list.forEach(x->System.out.println(x));//可以添加{}进行其他操作
list.forEach(System.out::println);//只能单纯打印 比较方便


         
        4. 

      4.  
        使用Iterator遍历集合
        

          

        • 在使用增强for循环遍历集合时是不能进行删除操作的
          • 

        • 可以使用iterator遍历集合使用iterator.remove()方法删除集合中的元素，不能使用集合自身的remove方法
          • 

        • 在使用iterator遍历集合修改元素对原集合没有影响
          • 

         
        5. 

      5.  
        HashSet(HashMap)添加元素过程
        

          

        • 先根据hashCode方法计算出hash值找到对应的槽
          • 

        • 如果该槽位没有元素，直接添加；如果有元素了，则沿着该槽位上的链表遍历，如果通过equals比较得到一个true,则添加失败；如果遍历完了该链表还没有equals成功，则在末尾添加上该元素
          • 

        • 一般情况下，hashCode相同equals不一定相同；但是equals相同hashCode应该也相同
          • 

        • ps: 不要修改已经添加进set中的元素的变量（参与hashCode equals计算）值
          • 

         
        class A{
    int a;
    @Override
    public int hashCode() {
        return this.a;
    }
    @Override
    public boolean equals(Object obj) {
        A x=(A)obj;
        return this.a==x.a;
    }
    public A(int a) {
        this.a = a;
    }
}
public static void main(String[] args) {
        A x= new A(123);
        HashSet<A> set=new HashSet<>();
        set.add(x);
        System.out.println(set.size());
        x.a=456;
        System.out.println(set.remove(new A(456)));//false 删除失败 因为x在set中的位置是123 位置456是空着的
        set.add(new A(123));//添加成功 该对象会落到123位置 该位置已经有x了 然后使用equals比较 由于x的a属性值被修改了 比较失败 equals返回false 因此添加成功
        System.out.println(set.size()); // 2
}

         
        6. 

      6.  
        TreeSet注意事项
        

          

        1. 默认升序，可以使用使用定制排序（Comparable）和自然排序（Comparable）自定义排序规则
          2. 

         
        TreeSet<Integer> treeSet=new TreeSet<>();
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);
System.out.println(treeSet);//1 2 3
TreeSet<Integer> treeSet2=new TreeSet<>((a,b)->b-a);//lambda简化了new Comparator
treeSet2.add(3);
treeSet2.add(1);
treeSet2.add(2);
System.out.println(treeSet2);//3 2 1

        

          

        1. 对自定义的对象如果相应使用TreeSet必须实现Comparable接口或者传入Comparator
          2. 

        2. 添加进TreeSet中的对象，如果再修改其属性值，不会触发二次排序
          3. 

        3. 如果compareTo（compare）方法总是返回1，则每次都能添加成功，有可能treeset中有多个元素引用，但是这些引用都是指向同一个对象的
          4. 

        4. equals返回true时，compareTo（compare)方法应该返回0
          5. 

         
        7. 

      7.  
        List接口注意事项
        

          

        1. 删除元素remove(Object obj)时是从头开始调用equals比较的，如果重写的equals一直返回true,则每次都会删除第一个元素
          2. 

        2. 同理，由于List是根据equals方法比较元素，如果重写的equals一直返回true,indexOf(obj)也会一直返回0
          3. 

         
        class A{
    int num;
    public A(int num) {
        this.num = num;
    }

    @Override
    public boolean equals(Object obj) {
        return true;
    }
}
public static void main(String[] args) {
        List<A> list=new ArrayList<>();
        A a1 = new A(123);
        A a2 = new A(456);
        list.add(a1);
        list.add(a2);
        System.out.println(list.indexOf(a2));//0
        list.remove(a2);//看似删除a2实际上把a1删除了
        System.out.println(list.get(0).num);//456
    }

         
        8. 

      8.  
        Arrays工具类
        

          

        1. 可以使用asList方法创建一个List,但是不能删除,也不能添加
          2. 

         
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
System.out.println(numbers);
System.out.println(numbers.getClass());//class java.util.Arrays$ArrayList
numbers.add(1);//报错
numbers.remove(1);//报错

        

          

        1. 常用方法还有：

            

          • public static void sort(int[] a)
            • 

          • public static int binarySearch(int[] a, int key)
            • 

          • public static void fill(int[] a, int val)
            • 

          • public static int[] copyOf(int[] original, int newLength)
            • 

           
          2. 

         
        9. 

      9.  
        HashMap
        

          

        • 判断两个键是否相等：hashCode相同并且equals方法返回true
          • 

        • 判断两个值是否相同：equals方法返回true即可
          • 

         
        10. 

      10.  
        Properties的使用
         
         public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        properties.setProperty("name","root");
        properties.setProperty("passwd","123");
        //写到文件中
        properties.store(new FileOutputStream("info.properties"),"user info");
        Properties properties1 = new Properties();

        //从properties文件中读取
        properties1.load(new FileInputStream("info.properties"));
        System.out.println(properties1);//{passwd=123, name=root}
        System.out.println(properties1.getProperty("name"));//root
    }

         
        11. 

      11.  
        WeakHashMap
        

          

        • HashMap中的key是强引用
          • 

        • WeakHashMap中的key是弱引用，若除了key之外没有其他引用引用对象，则该对象会被gc回收
          • 

         
         public static void main(String[] args) throws IOException {
        WeakHashMap<Object, String> weakHashMap = new WeakHashMap<>();
        weakHashMap.put(new Object(), "ob1");
        weakHashMap.put(new Object(), "ob2");
        weakHashMap.put(new Object(), "ob3");
        System.out.println(weakHashMap.size());//3
        System.gc();
        System.runFinalization();
        System.out.println(weakHashMap.size());//0
    }
//map中的key实际上是对象的引用 当发生gc后 三个obj对象被回收 之后weakHashMap会删除这三个对象对应的引用变量key-value对

         
        12. 

      12.  
        Collections工具类拥有的功能
        

          

        • 逆序 随机排序 排序 交换元素位置
          • 

        • 二分查找 max min fill 求某个元素出现的次数 替换
          • 

        • 包装原来的Collection接口实现类得到一个线程安全的实现类（本质上就是返回一个新的Collection实现类，该实现类的set get等操作加上了synchronized）
          • 

         
        13. 

       
      3. 

    

    

    4. 异常
    

      

    1.  
      无论使没使用try…catch，JVM都会产生一个异常对象，如果处理了，程序正常退出（Process finished with exit code 0），否则程序异常退出(Process finished with exit code 1)
       
      2. 

    2.  
      try后面的catch捕获的范围应该从小到大，从大到小会编译异常，cathch块只会执行一个
       
      3. 

    3.  
      try后面至少需要一个catch块或者finally块
       
      4. 

    4.  
      一个catch块中可以有多个异常
       
      try {
    int a = 1 / 0;
} catch (ArithmeticException | IndexOutOfBoundsException e) {
    e.printStackTrace();
}

       
      5. 

    5.  
      Throable(分类和继承体系)
      

        

      1. Error

          

        • IOError
          • 

        • LinkageError
          • 

        • ThreadDeath
          • 

         
        2. 

      2. Exception

          

        • RuntimeException

            

          • IndexOfBoundsException
            • 

          • NullPointerException
            • 

          • ClassCastException
            • 

           
          • 

        • IOException
          • 

         
        3. 

       
      6. 

    6.  
      fianlly块
      

        

      • 常用来回收关闭资源
        • 

      • 不管有没有发生异常，fianlly块一定会执行
        • 

      • 即使try中使用了return语句，fianlly块一定会执行
        • 

       
      private static void f() {
    try {
        int a = 1 / 1;
        return;
    } catch (ArithmeticException e) {
        e.printStackTrace();
    }finally {
        System.out.println("finally");
    }
}

      

        

      • finally返回值的几种情况
        • 

       
      /**
 * finally块中对a的累加赋值不会影响最终的返回值1
 * 因为在return a时a的值被保存了一份到栈中
 * @return 1
 */
private static int f() {
    int a=1;
    try {
        return a;
    } catch (ArithmeticException e) {
        e.printStackTrace();
    }finally {
        a=5;
        a++;
    }
    return -1;
}
/**
 * 在finally块中直接返回了
 * @return 6
 */
private static int f() {
    int a=1;
    try {
        return a;
    } catch (ArithmeticException e) {
        e.printStackTrace();
    }finally {
        a=5;
        a++;
        return a;
    }
}

      

        

      • 但是如果在try块中调用了System.exit(1)等方法，finally块是不会执行的
        • 

       
      7. 

    7.  
      运行时异常和编译时异常
      

        

      • 运行时异常：比如数组越界、除0异常，在编译期间是不能发现的
        • 

      • 编译时异常：比如IO读取，不使用try…catch进行处理编译是不能通过的
        • 

       
      8. 

    8.  
      Throws和Throw
      

        

      • Throws: 在函数签名后添加，表示当前函数不知道怎么处理异常，交给调用者处理，逐层往上，如果main函数也没有处理，则JVM会报错并打印错误信息
        • 

      • Throw： 一般用在catch或者finally块中，指定异常类型抛出，并给出自定义的异常信息, throw出类什么异常，方法签名应该throws出该异常或者该异常的父类
        • 

       
      try {
       int i=1/0;
   }catch (ArithmeticException e){
       throw new RuntimeException("除数不能为0");
   }

       
      9. 

    9.  
      子类重写父类的方法时，子类重写的方法的异常<=父类中的异常
       
      10. 

    10.  
      自定义异常类
       
      class MyException extends Exception{
    public MyException() {
    }
    public MyException(String message) {
        super(message);
        System.out.println("自定义异常");
    }
}
try {
   int i=1/0;
}catch (ArithmeticException e){
   throw new MyException("除数不能为0");
}

       
      11. 

    

    

    5. 注解
    

      

    1.  
      自定义注解使用@interface, 注解中的成员变量使用无参方法声明
       
      public @interface MyTag {
    String name() default "tom";
    int age() default 18;
}
public class Demo1 {
    @MyTag
   public void f(){

   }
}

       
      2. 

    2.  
      注解不会自己生效，需要开发者处理
       
      @Retention(value = RetentionPolicy.RUNTIME)//声明注解可以保留到运行时
public @interface MyTag {
    String name() default "tom";
    int age() default 18;
}
class A{
    public void f(){}
}
class A1 extends A{

    @MyTag(name = "bob",age = 19)
    @Override
    public void f() {
        super.f();
    }
}
 public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Annotation[] annotations = Class.forName("annotation.A1").getMethod("f").getAnnotations();
        System.out.println(annotations.length);//1 @Override注解在运行时获取不到
        for (Annotation annotation : annotations) {
            if(annotation instanceof MyTag){
                System.out.println("tag.name="+((MyTag) annotation).name());
                System.out.println("tag.age="+((MyTag) annotation).age());
            }
        }
    }

       
      3. 

    3.  
      3种注解范围
      

        

      1. @Retention(RetentionPolicy.SOURCE)
        2. 

      2. @Retention(RetentionPolicy.CLASS): 默认，不能通过发射获取
        3. 

      3. @Retention(RetentionPolicy.RUNTIME)，保留到运行时，可以通过反射获取
        4. 

       
      4. 

    4.  
      @Target(value = ElementType.FIELD)用来指明注解作用范围，作用于类、方法、属性…
       
      5. 

    5.  
      自定义一个类似于Junit中的@Test注解
       
      public class Demo1 {
    @MyTest
    public void f1(){
        System.out.println("f1");
    }
    @MyTest
    public void f2(){
        System.out.println("f2");
    }
    @MyTest
    public void f3(){
        System.out.println("f3");
    }
    @MyTest
    public void f4(){
        System.out.println("f4");
    }
    public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, IllegalAccessException {
        Method[] methods = Class.forName("annotation.Demo1").getMethods();
        Demo1 obj = new Demo1();
        for (Method method : methods) {
            if(method.isAnnotationPresent(MyTest.class)){
                method.invoke(obj);
            }
        }
    }
}

@Retention(value = RetentionPolicy.RUNTIME)
@Target(value = ElementType.METHOD)
public @interface MyTest {

}

       
      6. 

    

    

    6. JDBC
    

      

    1.  
      JBDC提供了一套接口，底层实现可以是mysql的驱动jar包，也可以是oracle的驱动jar包（这些jar包由数据库产商提供实现）
       
      2. 

    2.  
      数据库语言分类
      

        

      • DML： 数据操作语言，比如update insert deletw
        • 

      • DDL: 数据库定义语言，比如create alter drop truncate
        • 

      • DCL: 数据控制语言，grant revoke
        • 

      • 查询语句：select
        • 

       
      3. 

    3.  
      JDBC常用API
      

        

      • DriverManager
        • 

      • Connection
        • 

      • Statement
        • 

      • PreparedStatement
        • 

       
      4. 

    4.  
      JDBC编程步骤
      

        

      1. 加载数据库驱动Class.forName("com.mysql.jdbc.Driver"),最新的数据库驱动不需要这一步
        2. 

       
      5. 

    

    Java基础疑难点梳理(泛型到反射9章内容)_第1张图片
    

      

    1. 通过DriverManager获取Connection
      2. 

    2. 通过Connnection创建Statement对象（基本的Statement preparedStatement prepareCall）
      3. 

    3. 通过Statement执行SQL语句

        

      • boolean execute: 可以执行任何SQL语句
        • 

      • int executeUpdate: 执行DML DDL
        • 

      • ResultSet executeQuery: 查询
        • 

       
      4. 

    

    public static void main(String[] args) throws ClassNotFoundException {
        Class.forName("com.mysql.cj.jdbc.Driver");//加载数据库驱动 高版本mysql.jar包可以省略这一步
        String url="jdbc:mysql://localhost:3306/test?useSSL=true&serverTimezone=Asia/Shanghai";
        String userName="root";
        String password="123";
        try (//自动关闭资源的try用法
            //获取数据库连接
            Connection connection= DriverManager.getConnection(url,userName,password);
            Statement statement = connection.createStatement();
            ResultSet rs = statement.executeQuery("select  * from student");
        ){
            while(rs.next()){
                System.out.println("stuNo: "+rs.getInt("stuno")+" name: "+rs.getString("name"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    

      

    1.  
      execute
      

        

      • 可以执行几乎所有的sql语句
        • 

      • 只返回boolean值，表示是否返回了Result对象
        • 

      • 使用getResult方法获得Result对象，使用getUpdateCount获得DML语句影响的记录条数(是查询语句的话getUpdateCount返回-1)
        • 

       
      Connection connection= DriverManager.getConnection(url,userName,password);
Statement statement = connection.createStatement();
boolean hasResult = statement.execute("select  * from student");
if(hasResult){
    ResultSet resultSet = statement.getResultSet();
    while(resultSet.next()){
        System.out.println(resultSet.getInt("stuno")+"  "+resultSet.getString("name"));
        System.out.println(resultSet.getInt(1)+"  "+resultSet.getString(2));
    }
}

       
      2. 

    2.  
      PreparedStatement
      

        

      • 适用于被反复被执行的一条相似的sql语句,比如批量添加数据
        • 

       
      Connection connection= DriverManager.getConnection(url,userName,password);
//由于主键自增 所以第一个参数可以设置为null
PreparedStatement preparedStatement = connection.prepareStatement("insert into student values(null,?) ");
 for (int i = 0; i < 10; i++) {
    preparedStatement.setString(1,"Tim"+i);
    preparedStatement.execute();
}

      

        

      • 使用？占位符代替拼接的参数，普通的执行语句当参数时字符串时需要使用单引号引起来，这样容易导致Sql注入，所以PreparedStatement也可以防止sql注入
        • 

      • 优点总结：

          

        • 预编译，性能好
          • 

        • 无需拼接sql语句，编程简单
          • 

        • 防止sql注入
          • 

         
        • 

       
      3. 

    3.  
      Blob: 存储二进制数据到数据库（图片 视频等）
       
      //存储图片数据
Connection connection= DriverManager.getConnection(url,userName,password);
PreparedStatement preparedStatement = connection.prepareStatement("insert into student values(null,?,?) ");
for (int i = 0; i < 5; i++) {
    FileInputStream fileInputStream = new FileInputStream("1.jpg");
    preparedStatement.setString(1,"Tim"+i);
    preparedStatement.setBinaryStream(2,fileInputStream,fileInputStream.available());
    preparedStatement.execute();
}

//读取图片数据
 ResultSet resultSet = statement.executeQuery("select * from student");
    while (resultSet.next()){
       String name=resultSet.getString(2);
       Blob blob = resultSet.getBlob(3);//数据库表第3列村存储的是图片
       FileOutputStream out = new FileOutputStream(name+".jpg");
       out.write(blob.getBytes(1, (int) blob.length()));
}

       
      4. 

    4.  
      JDBC默认事务自动提交
      

        

      1. connection.setAutoCommit(false);： 开启事务，需要手动提交
        2. 

      2. connection.commit();: 手动提交事务
        3. 

      3. connection.rollback();: 回滚事务
        4. 

       
      5. 

    5.  
      批量操作
       
      Statement statement = connection.createStatement();
//只能添加DDL DML语句 不能执行查询语句
statement.addBatch("update student set name='tom111' where stuno=1");
statement.addBatch("update student set name='tom222' where stuno=2");
statement.addBatch("update student set name='tom333' where stuno=3");
int[] ret = statement.executeBatch();//每个sql语句执行结果的返回值

       
      6. 

    

    

    7. IO流
    

      

    1.  
      File类
      

        

      • 只能新建、删除、重命名文件和目录，不能访问文件内容本身
        • 

      • 如要访问文件内容本身，需要IO流
        • 

      • 常用方法分类

          

        • 访问文件名相关操作：获取文件（目录）相对路径，获取文件（目录）绝对路径，获取上一级目录
          • 

        • 文件检查相关方法：判断文件（目录）是否存在、判断是否可写（可读）、判断是否是文件（目录）
          • 

        • 获取文件信息：获得修改时间、获得文件内容长度
          • 

        • 文件操作相关方法：创建新的文件、删除文件、创建临时文件
          • 

        • 目录操作相关方法：创建目录、列数目录下的内容
          • 

         
        • 

       
      2. 

    2.  
      输入/输出流
      

        

      • 输入流：只能从中读数据
        • 

      • 输出流：只能往里写数据
        • 

      • 从内存的角度，往磁盘写数据是输出流，从磁盘读数据是输入流
        • 

      • 从网络编程的服务器角度，发送数据给客户端是输出流，客户端接受数据时输入流
        • 

       
      3. 

    3.  
      流的分类
      

        

      1. 输入流

          

        1. InputStream
          2. 

        2. Reader
          3. 

         
        2. 

      2. 输出流

          

        1. OutputStream
          2. 

        2. Writer
          3. 

         
        3. 

       
      4. 

    4.  
      InputStream和Reader（两个都是抽象类）
      

        

      1. InputStream中的方法

          

        • int read(): 返回字节数据
          • 

        • int read(byte[] b)：返回读取的实际字节数
          • 

        • int readByte(byte[] b,int off,int len)：返回读取的实际字节数
          • 

         
        2. 

      2. Reader中的方法

          

        • int read(): 返回字符数据
          • 

        • int read(char[] buf)：返回读取的实际字符数
          • 

        • int readByte(char[] buf,int off,int len)：返回读取的实际字符数
          • 

         
        3. 

       
      5. 

    5.  
      FileInputStream和FileReader
       
      /**
* FileInputStream
* 逐个字节读取 当有汉字时会出现乱码
*/
FileInputStream inputStream = new FileInputStream("a.txt");
int b=0;
while((b=inputStream.read())!=-1){
    System.out.println((char)b);
}

/**
 * FileInputStream
 * 使用字节数组读取
 * 也会出现中文乱码
 * 假设文件内容：中国
 * 字节数组b为3时可以读取正确（utf-8汉字3个字节编码）
 * 字节数组b为4时就会乱码
 */
FileInputStream inputStream = new FileInputStream("a.txt");
byte[] b=new byte[3];
int len;
while((len=inputStream.read(b))!=-1){
    System.out.println(new String(b,0,len));
}

 /**
 * FileReader
 * 逐个字符读取 不会发生中文乱码
 */
FileReader reader = new FileReader("a.txt");
int c=-1;
while((c= reader.read())>0){
    System.out.println((char)c);
}
/**
* FileReader
* 用字符数组读取
*/
FileReader reader = new FileReader("a.txt");
char[] buf=new char[4];
int len=-1;
while((len= reader.read(buf))>0){
    System.out.println(new String(buf,0,len));
}

       
      6. 

    6.  
      关于Unicode字符集和编码格式的一些思考
      

      

      Unicode给各国语言字符都设置了一个编号，比如汉字’中’的编号是20013，而UTF-8和GBK是编码格式，举个例子，8可以怎么表示，可以是0001000一个字节表示，也可以是0000000，0001000两个字节表示，不管你怎么表示，只要能最终根据表示方式还原成8即可；因此不管使用utf-8编码也好、gbk编码也好，只是把字符用不同的形式编码而已，码点值都是一样的，那么在解码时就可以安装相同的编码方式解码，得到正确的码点值，这样就不会产生乱码
      

       
      String s="你好";
System.out.println(s.getBytes("utf-8").length);//6 u8采用3个字节表示一个汉字
System.out.println(s.getBytes("gbk").length);//4 gbk采用2个字节表示一个汉字

//将一个utf-8编码的字符串转化成gbk编码的字符串
String s_utf8="你好";
byte[] bytes = s_utf8.getBytes("gbk");//先以gbk方式获取字节
String s_gbk=new String(bytes,"gbk");//再以gbk方式创建字符串
System.out.println(s_gbk);

//所以字节是通用的 这也就是为什么后面有转化流的出现
//假如一个文件的编码格式是gbk 平台系统的编码方式是utf-8 则可以先使用字节流以gbk的方式读取，然后转化成utf-8格式的字符输入流
//假如当前平台系统的编码方式是utf-8，需要将数据以gbk格式存储，则可以将字符数据以utf-8方式获取字节输出流，然后再转化成gbk格式的字符输出流

       
      7. 

    7.  
      OutputStream和Writer
      

        

      1.  
        OutputStream中的方法
        

          

        • void write(int c)
          • 

        • void write(byte[] b)
          • 

        • void write(byte[] b,int off,int len)
          • 

         
        2. 

      2.  
        Writer中的方法
        

          

        • void write(char c)
          • 

        • void write(char[] buf)
          • 

        • void write(char[] buf,int off,int len)
          • 

        • void write(String str)
          • 

        • void write(String str,int off,int len)
          • 

         
        3. 

      3.  
        FileOutputStream和Writer
         
        FileOutputStream outputStream = new FileOutputStream("out.txt");
int b=67;
outputStream.write(b);
byte[] bytes={'a','b','c'};
outputStream.write(bytes);
outputStream.write(bytes,1,2);
outputStream.flush();
outputStream.close();
//文件内容：Cabcbc

         
        FileWriter writer = new FileWriter("out.txt");
char c='a';
char[] buf={'b','c','d'};
String str="efg";
writer.write(c);
writer.write(buf);
writer.write(buf,1,2);
writer.write(str);
writer.write(str,1,2);
writer.flush();//不要忘记刷新
writer.close();//不要忘记关闭流 一般关闭时会自动刷新

         
        4. 

      4.  
        处理流(PrinsStream)用来包装节点流（FileInputStream FileOutputStream FileReader FileWriter）
         
        //处理流1PrintStream
FileOutputStream outputStream = new FileOutputStream("out.txt");
PrintStream printStream = new PrintStream(outputStream);
printStream.print("123");//没有换行符
printStream.println("hello world");//自动写入换行符
printStream.print("456");//没有换行符
printStream.close();//可以只关闭最上层处理流 被包装的节点流会被自动关闭
outputStream.close();

         
        5. 

      5.  
        转化流
        

          

        1.  
          InputStreamReader: 字符输入流->字节输入流
           
          2. 

        2.  
          OututStreamReader: 字符输出流->字符输出流
           
          3. 

        3.  
          ps: 没有字符流->字节流，因为没有必要，一是字符流使用起来更方便，二是字节流可以转化为字符流
           
          4. 

        4.  
          InputStreamReader使用场景：
           
          //out.txt是gbk编码的 内容：中国是一个伟大的国家!
FileReader reader = new FileReader("out.txt");
char[] buf=new char[1024];
int len=-1;
while((len=reader.read(buf))>0){
    System.out.println(new String(buf,0,len));
}
//输出：�й���һ��ΰ��Ĺ���!  因为机器是utf-8去解码的 所以乱码了

//解决：使用InputStreamReader转化
FileInputStream inputStream = new FileInputStream("out.txt");//字节读取是不管文件编码方式的
InputStreamReader reader = new InputStreamReader(inputStream,"gbk");//用gbk方式解码得到字符输出流
char[] buf=new char[1024];
int len=-1;
while((len=reader.read(buf))>0){
    System.out.println(new String(buf,0,len));
}

           
          5. 

        5.  
          OutputStreamReader使用场景：
           
          //当前系统编码是utf-8 需要将"中国是一个伟大的国家!"以gbk的编码格式写出
FileOutputStream outputStream = new FileOutputStream("out.txt");
OutputStreamWriter writer = new OutputStreamWriter(outputStream,"gbk");
writer.write("中国是一个伟大的国家!");
writer.close();

           
          6. 

         
        6. 

      6.  
        重定向输出
         
        FileOutputStream outputStream = new FileOutputStream("out.txt");
PrintStream printStream = new PrintStream(outputStream);
System.setOut(printStream);
System.out.println("hello world");
System.out.println("你好 世界");//本来应该打印到控制台 现在重定向到了文件中
printStream.close();

         
        7. 

      7.  
        重定向输入
         
        FileInputStream inputStream = new FileInputStream("out.txt");
System.setIn(inputStream);
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextLine()) {//无需键盘输入 直接从out.txt文件中读取数据
    System.out.println("键盘输入的内容： "+scanner.nextLine());
}

         
        8. 

      8.  
        对象流以及序列化反序列化
         
        //序列化
FileOutputStream outputStream = new FileOutputStream("obj.txt");
ObjectOutputStream stream = new ObjectOutputStream(outputStream);
Person p = new Person("tom", 18);
stream.writeObject(p);
stream.close();

//反序列化
FileInputStream inputStream = new FileInputStream("obj.txt");
ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
Person p = (Person) objectInputStream.readObject();
System.out.println("name: "+p.name+" age: "+p.age);
objectInputStream.close();

//序列化反序列化的对象需要实现Serializable（空接口）
class Person implements Serializable{
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
//如果序列化之后又修改了Person类就会反序列化失败
//添加序列化号的作用：
//private static final long serialVersionUID = 1; 名字必须是serialVersionUID
//序列号不变，即使修改了Person类也可以反序列化
//序列号改变，即使没有修改Person类反序列化也会失败
//总之，序列化和反序列化时的serialVersionUID应该是一样的 否则会反序列化失败

         
        9. 

      

        

      •  
        反序列化时不会调用构造器创建对象
         
        • 

      •  
        对某个成员属性如果不想被序列化，可以使用transient修饰
         
        • 

      •  
        静态变量不会被序列化
         
        • 

      •  
        带有引用属性的序列化
         
        //序列化
FileOutputStream outputStream = new FileOutputStream("obj.txt");
ObjectOutputStream stream = new ObjectOutputStream(outputStream);
Pet dog = new Pet("dog");
Person p1 = new Person("tom", dog);
stream.writeObject(p1);
Person p2 = new Person("bob", dog);//同一个对象只会被序列化一次  这里的dog只是一个引用编号
//每个序列化后的对象在磁盘中都有1个编号
stream.writeObject(p2);

//反序列化
FileInputStream inputStream = new FileInputStream("obj.txt");
ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
Person p1 = (Person) objectInputStream.readObject();
Person p2 = (Person) objectInputStream.readObject();
System.out.println(p1.pet==p2.pet);//true  
objectInputStream.close();

//两个类都要实现序列化接口
class Person implements Serializable{
    String name;
    Pet pet;

    public Person(String name, Pet pet) {
        this.name = name;
        this.pet = pet;
    }
}
class Pet implements Serializable{
    String name;

    public Pet(String name) {
        this.name = name;
    }
}

//多次写入同一个对象时 第二次以及后面写入时如果修改了对象的属性值是无效的
Pet dog = new Pet("dog");
Person p1 = new Person("tom", dog);
stream.writeObject(p1);
dog.name="small dog";//这里虽然修改了name 但是写入的还是原来的"dog"
Person p2 = new Person("bob", dog);
stream.writeObject(p2);

         
        • 

      •  
        对象类不仅可以写对象数据，基本类型的包装类型也可以写入
         
        FileOutputStream outputStream = new FileOutputStream("obj.txt");
ObjectOutputStream stream = new ObjectOutputStream(outputStream);
stream.writeInt(123);
stream.writeByte(1);
stream.writeDouble(3.14);
stream.close();

FileInputStream inputStream = new FileInputStream("obj.txt");
ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
System.out.println(objectInputStream.readInt());//读出顺序和吸入顺序需要一致
System.out.println(objectInputStream.readByte());
System.out.println(objectInputStream.readDouble());

         
        • 

      

        

      1. 文件复制的几种方式

          

        1. 传统IO读写（一个输入流，一个输出流）
          2. 

        2. NIO中的channel
          3. 

        3. Apache Commons IO中的FileUtils
          4. 

        4. Files文件工具类
          5. 

         
        2. 

       
      8. 

    

    

    8. 网络编程
    

      

    1.  
      IntetAddress表示IP地址，有Intet4Address和Intet6Address两个子类
       
      public static void main(String[] args) throws IOException {
    /**
     * 获取远程的InetAddress 对象
     */
    InetAddress address = InetAddress.getByName("www.baidu.com");
    System.out.println("是否可达： "+address.isReachable(2000));//true
    System.out.println(address.getHostName());//www.baidu.com
    System.out.println(address.getHostAddress());//14.215.177.39

    /**
     * 获取本地的netAddress 对象
     */
    InetAddress localHost = InetAddress.getLocalHost();
    System.out.println(localHost.getHostAddress());//10.170.11.18 本地机器的ip地址
    System.out.println(localHost.getHostName());//DESKTOP-GQBJPB6 计算机名称
}

       
      2. 

    2.  
      URLDecoder和URLEncoder
      

        

      • 当在浏览器输入的网址中含有中文字符时就会使用URL编码，如果能直接看到中文是因为浏览器自动解码了，复制网址重新黏贴就可以看到
        • 

       
      String keyWord="中国";
String encode = URLEncoder.encode(keyWord, "utf-8");
System.out.println(encode);//%E4%B8%AD%E5%9B%BD 可以看到是6个字节 因为u8编码每个汉字是3个字节
String decode = URLDecoder.decode(encode, "utf-8");
System.out.println(decode);//中国

       
      3. 

    3.  
      TCP通信
       
      //服务端代码
public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        List<Socket> sockets=new ArrayList<>();
        while (true){
            Socket accept = serverSocket.accept();
            sockets.add(accept);//
            //开启一个单独的线程处理连接上来的客户端
            //不开启多线程的话 代码会一直在content=bufferedReader.readLine()阻塞 导致不能连接下一个客户端
            new Thread(()->{
                try {
                    InputStream inputStream = accept.getInputStream();
                    InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
                    BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
                    String content=null;
                    //服务端收发信息都是用到客户端socket的输入输出流
                    while((content=bufferedReader.readLine())!=null){
                        System.out.println("服务端收到： "+content);
                        for (Socket socket : sockets) {
                            if(socket==accept){
                                continue;//不发送信息给自己
                            }
                            OutputStream outputStream = socket.getOutputStream();
                            PrintStream printStream = new PrintStream(outputStream);
                            printStream.println(content);
                            printStream.close(); //关闭会导致客户端socket
                        }
                    }

                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }

    }

//客户端代码
 public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1", 9999);
        //负责接受消息的线程
        new Thread(()->{
            try {
                InputStream inputStream = socket.getInputStream();
                InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
                BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
                String s=null;
                while((s=bufferedReader.readLine())!=null){
                    System.out.println(s);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }).start();

        //主线程负责发送消息
        OutputStream outputStream = socket.getOutputStream();
        //包装成打印流
        PrintStream printStream = new PrintStream(outputStream);
        Scanner scanner = new Scanner(System.in);
        String content=null;
        while((content=scanner.nextLine())!=null){
            printStream.println(content);
        }
        socket.close();

    }

       
      4. 

    4.  
      半关闭状态
      

        

      • 服务端怎么知道客户端发送数据结束了呢？可以通过直接关闭客户端的socket实现：socket.close(), 但这样会导致一个问题，客户端只是不想发送数据了，关闭socket会导致也不能接受数据
        • 

      • shutdownOutput(): 关闭socket的输出流，输入流不受影响
        • 

      • shutdownInput(): 关闭socket的输入流，输出流不受影响
        • 

       
      public static void main(String[] args) throws IOException {
    ServerSocket serverSocket = new ServerSocket(9999);
    Socket socket = serverSocket.accept();
    InputStream inputStream = socket.getInputStream();
    InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
    BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
    String s=null;
    while((s=bufferedReader.readLine())!=null){
        System.out.println(s);
    }
    System.out.println("读取结束...");
    System.in.read();//防止服务器主线程结束
}

public static void main(String[] args) throws IOException {
    Socket socket = new Socket("127.0.0.1", 9999);
    OutputStream outputStream = socket.getOutputStream();
    PrintStream printStream = new PrintStream(outputStream);
    printStream.println("这是第一条消息");
    printStream.println("这是第二条消息");
    printStream.println("这是最后一条消息");
    System.in.read();//防止客户端主线程结束
}
//虽然客户端数据发送完毕了 但是服务器还是一直在等待数据的发送
//在printStream.println("这是最后一条消息");后加上socket.shutdownOutput();则通知服务器客户度消息已经发送完毕了
//相当于四次挥手的前两次挥手操作

       
      5. 

    5.  
      UDP通信
       
      //服务端
 public static void main(String[] args) throws IOException {
    DatagramSocket socket = new DatagramSocket( 9999,InetAddress.getByName("localhost"));
    DatagramPacket outPacket = new DatagramPacket(new byte[0], 0, InetAddress.getByName("localhost"), 9998);
    byte[] inBuf = new byte[1024];
    DatagramPacket inPacket = new DatagramPacket(inBuf,inBuf.length);
    while (true){
        socket.receive(inPacket);//接收客户端的消息
        System.out.println("客户端ip: "+inPacket.getAddress());
        System.out.println("客户度端口："+inPacket.getPort());
        String resp="我是服务端，我收到了消息: "+new String(inBuf,0,inPacket.getLength());
        outPacket.setData(resp.getBytes());//发送消息给客户端
        socket.send(outPacket);
    }
}

//客户端
public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket( 9998, InetAddress.getByName("localhost"));
        DatagramPacket outPacket = new DatagramPacket(new byte[0], 0, InetAddress.getByName("localhost"), 9999);
        byte[] inBuf = new byte[1024];
        DatagramPacket inPacket = new DatagramPacket(inBuf,inBuf.length);
        Scanner scanner = new Scanner(System.in);
        String s=null;
        while((s=scanner.nextLine())!=null){
            outPacket.setData(s.getBytes());
            socket.send(outPacket);//发送给服务端
            socket.receive(inPacket);//接受服务端的消息
            System.out.println(new String(inBuf,0,inPacket.getLength()));
        }
    }
//接收包和发送包的端口都是目的端口

      

        

      • UPD通信时客户端和服务端并没有明显的区分
        • 

      • UDP通信步骤：1.创建DatagramSocket 2.创建DatagramPacket（发送包和接收包） 3. send发送 receive接收
        • 

      • send receive方法是阻塞的
        • 

       
      6. 

    6.  
      UPD实现广播通信
       
      public static void main(String[] args) throws IOException {
    MulticastSocket multicastSocket = new MulticastSocket(9999);
    //广播地址：224.0.0.0~239.255.255.255
    InetAddress address = InetAddress.getByName("230.0.0.1");
    multicastSocket.joinGroup(address);
    multicastSocket.setLoopbackMode(false);
    DatagramPacket outPacket = new DatagramPacket(new byte[0], 0, address, 9999);
    byte[] inBuf = new byte[1024];
    DatagramPacket inPacket = new DatagramPacket(inBuf,inBuf.length);
    new Thread(()->{
        //接收数据
        while (true) {
            try {
                multicastSocket.receive(inPacket);
                System.out.println(new String(inBuf, 0, inPacket.getLength()));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }).start();
    Scanner scanner = new Scanner(System.in);
    String s=null;
    //发送数据
    while((s=scanner.nextLine())!=null){
        outPacket.setData(s.getBytes());
        multicastSocket.send(outPacket);
    }
}

      

        

      • 启动多个客户端,MulticastSocket multicastSocket = new MulticastSocket(9999);, 端口不冲突
        • 

       
      7. 

    7.  
      端口问题
      

        

      • DatagramSocket ServerSocket Socket MulticastSocket 可以同时共享一个端口
        • 

      • UDP通信时客户端服务端端口不能相同
        • 

      • TCP通信和UDP通信时可以端口相同
        • 

       
      8. 

    

    

    9. 类加载和反射
    

      

    1.  
      java程序运行在JVM进程中，即使这个java程序中有多个线程（一个进程里面可以有多个线程，这个进程就是JVM进程），每运行一次JVM进程，上一次运行时JVM内存中的变量数据都会丢失，可以有多个JVM进程，多个进程之间相互独立，不会共享数据
       
      Java基础疑难点梳理(泛型到反射9章内容)_第2张图片Java基础疑难点梳理(泛型到反射9章内容)_第3张图片
       
      2. 

    2.  
      类的加载分为三个阶段
      

        

      1. 类加载：将类的class文件读入内存，并为之创建一个java.lang.Class对象（类也是一种对象，是Class类实例化得到的对象,通常是说类的实例化得到对象，eg: 名字可以实例化，你的名字叫"李明"（“李明"是对象），我的名字就叫"名字”（"名字"是类对象），类加载由类加载器完成
        2. 

      2. 连接：将类的二进制数据合并到JRE中

          

        • 验证：class文件格式是否正确
          • 

        • 准备：给类的静态变量分配内存并设置初始值
          • 

        • 解析：将类的二进制数据中的符号引用替换成直接引用
          • 

         
        3. 

      3. 初始化：对静态变量初始化赋值（程序员显示设置的值）

          

        • 如果当前类还没有被加载和连接，先进行加载和连接再初始化
          • 

        • 如果当前类的父类还没有被初始化，先初始化父类
          • 

        • 类中的初始化语句（静态变量赋值语句 静态代码块）按顺序执行
          • 

         
        4. 

       
      3. 

    3.  
      class文件来源：本地的class文件 jar包中的class文件 从网络加载class文件 把一个Java源文件动态编译并完成加载
       
      4. 

    4.  
      类的初始化时机：
      

        

      • 创建类的实例
        • 

      • 调用类的静态方法
        • 

      • 访问类的静态变量(fianl修饰的在编译期间可以确定下来的常量除外)

          

        • 可以确定：static fianl String s="hello"
          • 

        • 不可以确定：static final String s=System.currentMills()+""
          • 

         
        • 

      • 使用反射创建某个类的Class对象
        • 

      • 初始化当前类的子类（父类要在子类前初始化）
        • 

      • java.exe命令运行某个main方法，main方法所在的类会被初始化
        • 

       
      5. 

    5.  
      同一个类只会被JVM加载到内存一次，怎么算同一个类? 由类的全限定类名和类加载器确定，即使全限定类名相同，类加载器不同，也是不同的类
       
      6. 

    6.  
      类加载器分类
      

      

       

      

       

      

       

      

      
用户自定义加载器

      

      
应用类类加载器

      

      
应用类加载器

      

      
拓展类加载器

      

      
根类加载器

      

       
      类加载机制：
      

        

      1. 全盘负责：一个类加载器加载某个类时会加载该类所依赖和引用的其他类
        2. 

      2. 父类委托：先让父类加载，父类无法加载时自己才加载
        3. 

      3. 缓存机制：加载过的类会被缓存，需要时先从缓存区找，找不到再加载
        4. 

       
      public static void main(String[] args) {
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();//系统类加载器
        System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2
        ClassLoader classLoader = Demo1.class.getClassLoader();//当前类的加载器
        System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2
        System.out.println(systemClassLoader==classLoader);//true 当前类的加载器就是系统类加载器
        //获取系统类加载器路径
        //如果配置CLASSPATH环境变量会打印环境变量 否则打印当前类的路径
        URL resource = systemClassLoader.getResource("");
        System.out.println(resource);//file:/D:/IdeaSpace/java_basis/out/production/java_basis/

        ClassLoader extendsLoader = systemClassLoader.getParent();
        System.out.println(extendsLoader);//sun.misc.Launcher$ExtClassLoader@74a14482

        ClassLoader rootLoader = extendsLoader.getParent();
        System.out.println(rootLoader);//null 根加载器不是java实现的
    }

       
      7. 

    7.  
      类加载器加载Class步骤（不包含连接、初始化）
      

      

       是

      

       否

      

       是

      

       否

      

       

      

       是

      

       

      

       是

      

       否

      

       否

      

       

      

       

      

       是

      

       否

      

       

      

      
Class是否已经被加载?

      

      
返回对应的Class对象

      

      
父加载器是否存在?

      

      
父加载器加载Class

      

      
使用根加载器加载

      

      
加载成功?

      

      
加载成功?

      

      
ClassNotFoundException

      

      
使用当前类加载

      

      
从当前类路径中寻找该类

      

      
是否找到?

      

      
从文件中加载Class

      

       
      8. 

    8.  
      自定义类加载器
       
      public class MyClassLoader extends ClassLoader{
    //    包路径
    private String Path;

    //    构造方法，用于初始化Path属性
    public MyClassLoader(String path) {
        this.Path = path;
    }

    //    重写findClass方法，参数name表示要加载类的全类名(包名.类名)
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        System.out.println("findclass方法执行");

//        检查该类的class文件是否已被加载，如果已加载则返回class文件(字节码文件)对象，如果没有加载返回null
        Class<?> loadedClass = findLoadedClass(name);
//        如果已加载直接返回该类的class文件(字节码文件)对象
        if (loadedClass != null){
            return loadedClass;
        }

//        字节数组，用于存储class文件的字节流
        byte[] bytes = null;
        try {
//            获取class文件的字节流
            bytes = getBytes(name);
        } catch (Exception e) {
            e.printStackTrace();
        }


        if (bytes != null){
//        如果字节数组不为空，则将class文件加载到JVM中
            System.out.println(bytes.length);
//            将class文件加载到JVM中，返回class文件对象
            Class<?> aClass = this.defineClass(name, bytes, 0, bytes.length);
            return aClass;
        }else {
            throw new ClassNotFoundException();
        }
    }

    //    获取class文件的字节流
    private byte[] getBytes(String name) throws Exception{
//        拼接class文件路径 replace(".",File.separator) 表示将全类名中的"."替换为当前系统的分隔符，File.separator返回当前系统的分隔符
        String FileUrl = Path + name.replace(".", File.separator) + ".class";
        byte[] bytes;
//        相当于一个缓存区，动态扩容，也就是随着写入字节的增加自动扩容
        ByteArrayOutputStream arrayOutputStream = new ByteArrayOutputStream();
        File file = new File(FileUrl);
//        创建输入流
        InputStream inputStream = new FileInputStream(file);
        int content;
//        循环将输入流中的所有数据写入到缓存区中
        while ((content = inputStream.read()) != -1){
            arrayOutputStream.write(content);
            arrayOutputStream.flush();
        }
        bytes = arrayOutputStream.toByteArray();
        return bytes;
    }
}


public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
    //构造器的参数是类的class文件所在的目录
    MyClassLoader myClassLoader = new MyClassLoader("D:\\IdeaSpace\\java_basis\\out\\production\\java_basis\\");
    Class<?> loadClass = myClassLoader.findClass("test.Hello");
    Class<?> loadClass2 = myClassLoader.findClass("test.Hello");
    System.out.println(loadClass==loadClass2);//true 相同的类加载器某个类只会被加载一次

    MyClassLoader myClassLoader2 = new MyClassLoader("D:\\IdeaSpace\\java_basis\\out\\production\\java_basis\\");
    Class<?> loadClass3 = myClassLoader2.findClass("test.Hello");
    System.out.println(loadClass==loadClass3);//false 相同的类 但是是不同的类加载器（创建了两个MyClassLoader对象）


    Object o = loadClass.newInstance();
    System.out.println(o);//test.Hello@6d6f6e28
    ClassLoader myLoader = loadClass.getClassLoader();
    ClassLoader appLoader = myLoader.getParent();
    ClassLoader extendsLoader = appLoader.getParent();
    ClassLoader rootLoader = extendsLoader.getParent();
    System.out.println(myLoader);//test.MyClassLoader@1540e19d
    System.out.println(appLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2
    System.out.println(extendsLoader);//sun.misc.Launcher$ExtClassLoader@7f31245a
    System.out.println(rootLoader);//null

}


       
      9. 

    9.  
      获得Class对象
      

        

      • Class.forName
        • 

      • Person.class这种形式
        • 

      • p.getClass()
        • 

       
      10. 

    10.  
      Class对象和普通对象一样，里面有很多方法
      

        

      • 可以获得Class对象对应类的构造器
        • 

      • 可以获得Class对象对应类的的方法
        • 

      • 可以获得Class对象对应类的成员变量
        • 

       
      public static void main(String[] args) {
        Person person = new Person();
        Class<? extends Person> personClass = person.getClass();
        /**
         * 获取Person类中的构造器
         * 输出结果
         * public test.Person()
         * public test.Person(java.lang.String,int)
         */
        Constructor<?>[] constructors = personClass.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }

        /**
         * 获取Person类中的方法
         * 会打印方法签名 不包括父类中的方法
         * static int test.Person.f()
         * void test.Person.info(java.lang.String)
         */
        Method[] methods = personClass.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

        /**
         * 获取Person类中的属性
         * java.lang.String test.Person.name
         * int test.Person.age
         * static int test.Person.a
         */
        Field[] fields = personClass.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
    }
//带Declared的获得的方法或属性和访问权限无关
//不带Declared只能获得public权限的方法或属性

       
      11. 

    11.  
      使用反射创建对象
       
      Class<Person> personClass = Person.class;
Person person1 = personClass.newInstance();//调用无参构造器创建对象
Constructor<Person> constructor1 = personClass.getConstructor();//获取无参构造器
Person person2 = constructor1.newInstance();
Constructor<Person> constructor2 = personClass.getConstructor(String.class, int.class);//获取有参构造器
Person person3 = constructor2.newInstance("tom", 18);
System.out.println(person1);//Person{name='null', age=0}
System.out.println(person2);//Person{name='null', age=0}
System.out.println(person3);//Person{name='tom', age=18}

       
      12. 

    12.  
      使用反射调用方法
       
      Class<Person> personClass = Person.class;
Person person = new Person();
Method f1 = personClass.getMethod("f1", int.class);
Object ret1 = f1.invoke(person, 999);//f1是成员方法 第一个参数需要一个peron对象
System.out.println(ret1);//返回1
Method f2 = personClass.getMethod("f2", String.class, int.class);
Object ret2 = f2.invoke(null, "hello", 123);//f2是一个静态方法 不需要对象 所以第一个参数为null
System.out.println(ret2);//f2是void类型 返回null

public class Person {
   public int f1(int a){
       System.out.println("a="+a);
       return 1;
   }
   public static void f2(String s,int a){
       System.out.println("s="+s);
       System.out.println("a="+a);
   }
}

       
      13. 

    13.  
      访问成员变量的值
       
      Class<Person> personClass = Person.class;
Person person = new Person();
System.out.println(person.a);//1
Field a = personClass.getDeclaredField("a");
a.set(person,111);//通过反射修改a的值 a是成员变量 第一个参数需要传入一个person对象
System.out.println(person.a);//111
Field b = personClass.getDeclaredField("b");
b.setAccessible(true);//b是private 需要先取消权限访问检查
b.set(person,222);

Field c = personClass.getDeclaredField("c");
System.out.println(Person.c);//3
c.set(null,333);//c是静态变量 设置值时第一个参数为null即可
System.out.println(Person.c);//333

public class Person {
   public int a=1;
   private int b=2;
   static int c=3;
}

       
      14. 

    14.  
      使用反射操作数组
       
      public static void main(String[] args) throws Exception {
        Object arr = Array.newInstance(int.class, 10);//创建大小为10的int类型数组
        Array.set(arr,1,100);//给数组元素赋值 arr[1]=100
        Array.set(arr,2,200);
        Object ele = Array.get(arr, 1);//获取数组元素的值
        System.out.println(ele);

        /**
         * 使用Array获取数组属性
         */
        int[][] nums=new int[3][4];
        getArrayDimensions(nums);

    }
public static void getArrayDimensions(Object arr){
    if(arr.getClass().isArray()){
        System.out.println(Array.getLength(arr));//打印数组维度
        getArrayDimensions(Array.get(arr,0));
    }
}

       
      15. 

    15.  
      JDK动态代理步骤
      

        

      1. 创建一个接口和实现类（被代理的类）
        2. 

      2. 创建一个InvocationHandler
        3. 

      3. 创建代理对象
        4. 

      4. 代理对象调用方法
        5. 

       
      //1. 创建一个接口和实现类（被代理的类）
interface Dog{
    void info();
    String say(String name,int age);
}
class JinMao implements Dog{

    @Override
    public void info() {
        System.out.println("我是一只金毛");
    }

    @Override
    public String say(String name, int age) {
        return "金毛： name="+name+" age="+age;
    }
}
class Keji implements Dog{

    @Override
    public void info() {
        System.out.println("我是一只柯基");
    }

    @Override
    public String say(String name, int age) {
        return "柯基： name="+name+" age="+age;
    }
}

//2. 创建一个InvocationHandler
class MyInvocationHandler implements InvocationHandler{
    Dog dog;//被代理的对象 用接口类型表示 可以接受多个子类对象

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(method.getName()+"方法开始执行...");
	    System.out.println(proxy.getClass());//class test.$Proxy0
        if(args!=null){
            System.out.println("参数："+ Arrays.toString(args));
        }
        Object result = method.invoke(dog, args);//反射调用方法 传入一个对象
        System.out.println(method.getName()+"方法执行结束...");
        return result;
    }
}

//3. 创建代理对象
// Dog dog = new JinMao();
Dog dog=new Keji();
MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
myInvocationHandler.setDog(dog);
//只能强转为接口Dog类型 不能强转为子类类型
Dog dogProxy = (Dog) Proxy.newProxyInstance(dog.getClass().getClassLoader(), dog.getClass().getInterfaces(),myInvocationHandler);
//4. 代理对象调用方法
dogProxy.info();
dogProxy.say("tom",4);

       
      16. 

    16.  
      反射与泛型
       
      Class<Person> personClass = Person.class;
Field a = personClass.getDeclaredField("a");
System.out.println(a.getType());//int
Field intList = personClass.getDeclaredField("intList");
Field doubleList = personClass.getDeclaredField("doubleList");
Field map = personClass.getDeclaredField("map");
System.out.println(intList.getType());//interface java.util.List 
System.out.println(intList.getGenericType());//java.util.List
System.out.println(doubleList.getType());//interface java.util.List
System.out.println(doubleList.getGenericType());//java.util.List
System.out.println(map.getType());//interface java.util.Map
System.out.println(map.getGenericType());//java.util.Map

public class Person {
   int a=1;
   List<Integer> intList;
   List<Double> doubleList;
   Map<String ,Integer> map;
}
//getType只能获取基本类型的形式 不能获取泛型参数信息 getGenericType可以获取泛型参数信息

       
      17. 

    







    



    


    


    




    

    你可能感兴趣的:(Java,java,开发语言)
    

    

    

      

    • Long类型前后端数据不一致
igotyback
前端

      响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
      

      • 

    • LocalDateTime 转 String
igotyback
java开发语言

      importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
      

      • 

    • Linux下QT开发的动态库界面弹出操作（SDL2）
13jjyao
QT类qt开发语言sdl2linux

      需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
      

      • 

    • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业

      ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
      

      • 

    • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
若博豆
java算法华为javascript

      华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
      

      • 

    • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
二挡起步
web前端期末大作业javascripthtmlcss旅游风景

      ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
      

      • 

    • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端

      Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
      

      • 

    • node.js学习
小猿L
node.jsnode.js学习vim

      node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
      

      • 

    • Java 重写(Override)与重载(Overload)
叨唧唧的

      Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
      

      • 

    • 简单了解 JVM
记得开心一点啊
jvm

      目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
      

      • 

    • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
Energet!c
开发语言

      1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
      

      • 

    • Java企业面试题3
马龙强_
java

      1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
      

      • 

    • JVM、JRE和 JDK：理解Java开发的三大核心组件
Y雨何时停T
Javajava

      Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
      

      • 

    • Java面试题精选：消息队列(二)
芒果不是芒
Java面试题精选javakafka

      一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
      

      • 

    • 白骑士的Java教学基础篇 2.5 控制流语句
白骑士所长
Java教学java开发语言

      欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
      

      • 

    • python语法——三目运算符
HappyRocking
pythonpython三目运算符

      在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
      

      • 

    • ArrayList 源码解析
程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea

      ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
      

      • 

    • Java爬虫框架（一）--架构设计
狼图腾-狼之传说
java框架java任务html解析器存储电子商务

      一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
      

      • 

    • Java：爬虫框架
dingcho
Javajava爬虫

      一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
      

      • 

    • python怎么将png转为tif_png转tif
weixin_39977276

      发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
      

      • 

    • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
跳房子的前端
前端面试javascript开发语言ecmascript

      在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
      

      • 

    • JAVA·一个简单的登录窗口
MortalTom
java开发语言学习

      文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
      

      • 

    • WebMagic：强大的Java爬虫框架解析与实战
Aaron_945
Javajava爬虫开发语言

      文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
      

      • 

    • 博客网站制作教程
2401_85194651
javamaven

      首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
      

      • 

    • 00. 这里整理了最全的爬虫框架（Java + Python）
有一只柴犬
爬虫系列爬虫javapython

      目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
      

      • 

    • JAVA学习笔记之23种设计模式学习
victorfreedom
Java技术设计模式androidjava常用设计模式

      博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
      

      • 

    • JavaScript `Map` 和 `WeakMap`详细解释
跳房子的前端
JavaScript原生方法javascript前端开发语言

      在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
      

      • 

    • 切换淘宝最新npm镜像源是
hai40587
npm前端node.js

      切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
      

      • 

    • 【Java】已解决：java.util.concurrent.CompletionException
屿小夏
java开发语言

      文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
      

      • 

    • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
ok!ko
设计模式设计模式建造者模式java

      文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
      

      • 

    • 微信开发者验证接口开发
362217990
微信 开发者 token 验证

      微信开发者接口验证。
Token，自己随便定义，与微信填写一致就可以了。
根据微信接入指南描述 http://mp.weixin.qq.com/wiki/17/2d4265491f12608cd170a95559800f2d.html
第一步：填写服务器配置
第二步：验证服务器地址的有效性
第三步：依据接口文档实现业务逻辑
这里主要讲第二步验证服务器有效性。
建一个
      

      • 

    • 一个小编程题-类似约瑟夫环问题
BrokenDreams
编程

              今天群友出了一题：
        一个数列,把第一个元素删除,然后把第二个元素放到数列的最后,依次操作下去,直到把数列中所有的数都删除,要求依次打印出这个过程中删除的数。
     &
      

      • 

    • linux复习笔记之bash shell (5) 关于减号-的作用
eksliang
linux关于减号“-”的含义linux关于减号“-”的用途linux关于“-”的含义linux关于减号的含义

          转载请出自出处：
http://eksliang.iteye.com/blog/2105677   
    管道命令在bash的连续处理程序中是相当重要的，尤其在使用到前一个命令的studout（标准输出）作为这次的stdin（标准输入）时，就显得太重要了，某些命令需要用到文件名，例如上篇文档的的切割命令（split）、还有
      

      • 

    • Unix(3)
18289753290
unix ksh

      1)若该变量需要在其他子进程执行，则可用"$变量名称"或${变量}累加内容
什么是子进程？在我目前这个shell情况下，去打开一个新的shell，新的那个shell就是子进程。一般状态下，父进程的自定义变量是无法在子进程内使用的，但通过export将变量变成环境变量后就能够在子进程里面应用了。
2)条件判断： &&代表and  ||代表or&nbs
      

      • 

    • 关于ListView中性能优化中图片加载问题
酷的飞上天空
ListView

      ListView的性能优化网上很多信息，但是涉及到异步加载图片问题就会出现问题。
具体参看上篇文章http://314858770.iteye.com/admin/blogs/1217594
 
如果每次都重新inflate一个新的View出来肯定会造成性能损失严重，可能会出现listview滚动是很卡的情况，还会出现内存溢出。
现在想出一个方法就是每次都添加一个标识，然后设置图
      

      • 

    • 德国总理默多克：给国人的一堂“震撼教育”课
永夜-极光
教育

      http://bbs.voc.com.cn/topic-2443617-1-1.html德国总理默多克：给国人的一堂“震撼教育”课　
安吉拉—默克尔，一位经历过社会主义的东德人，她利用自己的博客，发表一番来华前的谈话，该说的话，都在上面说了，全世界想看想传播——去看看默克尔总理的博客吧！
　　德国总理默克尔以她的低调、朴素、谦和、平易近人等品格给国人留下了深刻印象。她以实际行动为中国人上了一堂
      

      • 

    • 关于Java继承的一个小问题。。。
随便小屋
java

      今天看Java 编程思想的时候遇见一个问题，运行的结果和自己想想的完全不一样。先把代码贴出来！
//CanFight接口
interface Canfight {
void fight();
}
//ActionCharacter类
class ActionCharacter {
public void fight() {
System.out.pr
      

      • 

    • 23种基本的设计模式
aijuans
设计模式

      Abstract Factory：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 　　Adapter：将一个类的接口转换成客户希望的另外一个接口。A d a p t e r模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 　　Bridge：将抽象部分与它的实现部分分离，使它们都可以独立地变化。 　　Builder：将一个复杂对象的构建与它的表示分离，使得同
      

      • 

    • 《周鸿祎自述：我的互联网方法论》读书笔记
aoyouzi
读书笔记

      从用户的角度来看,能解决问题的产品才是好产品,能方便/快速地解决问题的产品,就是一流产品.
 
商业模式不是赚钱模式
一款产品免费获得海量用户后,它的边际成本趋于0,然后再通过广告或者增值服务的方式赚钱,实际上就是创造了新的价值链.
 
商业模式的基础是用户,木有用户,任何商业模式都是浮云.商业模式的核心是产品,本质是通过产品为用户创造价值.
商业模式还包括寻找需求
      

      • 

    • JavaScript动态改变样式访问技术
百合不是茶
JavaScriptstyle属性ClassName属性

       
一:style属性
格式: 
HTML元素.style.样式属性="值";
 
创建菜单:在html标签中创建 或者 在head标签中用数组创建
 
<html>
<head>
<title>style改变样式</title>
</head>
&l
      

      • 

    • jQuery的deferred对象详解
bijian1013
jquerydeferred对象

              jQuery的开发速度很快，几乎每半年一个大版本，每两个月一个小版本。
        每个版本都会引入一些新功能，从jQuery 1.5.0版本开始引入的一个新功能----deferred对象。
   &nb
      

      • 

    • 淘宝开放平台TOP
Bill_chen
C++c物流C#

      淘宝网开放平台首页：http://open.taobao.com/
淘宝开放平台是淘宝TOP团队的产品，TOP即TaoBao Open Platform，
是淘宝合作伙伴开发、发布、交易其服务的平台。
支撑TOP的三条主线为：
   1.开放数据和业务流程
    * 以API数据形式开放商品、交易、物流等业务；
 &
      

      • 

    • 【大型网站架构一】大型网站架构概述
bit1129
网站架构

      大型互联网特点
面对海量用户、海量数据
大型互联网架构的关键指标
高并发
高性能
高可用
高可扩展性
线性伸缩性
安全性
大型互联网技术要点
 
前端优化
CDN缓存
反向代理
KV缓存
消息系统
分布式存储
NoSQL数据库
搜索
监控
安全
想到的问题：
1.对于订单系统这种事务型系统，如
      

      • 

    • eclipse插件hibernate tools安装
白糖_
Hibernate

      
eclipse helios(3.6)版
1.启动eclipse 2.选择 Help > Install New Software...> 3.添加如下地址：
http://download.jboss.org/jbosstools/updates/stable/helios/ 4.选择性安装：hibernate tools在All Jboss tool
      

      • 

    • Jquery easyui Form表单提交注意事项
bozch
jquery easyui

      jquery easyui对表单的提交进行了封装，提交的方式采用的是ajax的方式，在开发的时候应该注意的事项如下：
        1、在定义form标签的时候，要将method属性设置成post或者get，特别是进行大字段的文本信息提交的时候，要将method设置成post方式提交，否则页面会抛出跨域访问等异常。所以这个要
      

      • 

    • Trie tree(字典树)的Java实现及其应用-统计以某字符串为前缀的单词的数量
bylijinnan
java实现

      
import java.util.LinkedList;
public class CaseInsensitiveTrie {
/**
字典树的Java实现。实现了插入、查询以及深度优先遍历。
Trie tree's java implementation.(Insert,Search,DFS)
Problem Description
Igna
      

      • 

    • html css 鼠标形状样式汇总
chenbowen00
htmlcss

      css鼠标手型cursor中hand与pointer 
Example：CSS鼠标手型效果 <a href="#" style="cursor:hand">CSS鼠标手型效果</a><br/> 
Example：CSS鼠标手型效果 <a href="#" style=&qu
      

      • 

    • [IT与投资]IT投资的几个原则
comsci
it

      
      无论是想在电商,软件,硬件还是互联网领域投资,都需要大量资金,虽然各个国家政府在媒体上都给予大家承诺,既要让市场的流动性宽松,又要保持经济的高速增长....但是,事实上,整个市场和社会对于真正的资金投入是非常渴望的,也就是说,表面上看起来,市场很活跃,但是投入的资金并不是很充足的......
   
      

      • 

    • oracle with语句详解
daizj
oraclewithwith as

      oracle with语句详解 转
在oracle中，select 查询语句，可以使用with,就是一个子查询，oracle 会把子查询的结果放到临时表中，可以反复使用
例子:注意，这是sql语句，不是pl/sql语句， 可以直接放到jdbc执行的
----------------------------------------------------------------
      

      • 

    • hbase的简单操作
deng520159
数据库hbase

      近期公司用hbase来存储日志,然后再来分析 ,把hbase开发经常要用的命令找了出来.
用ssh登陆安装hbase那台linux后
用hbase shell进行hbase命令控制台!
表的管理
1）查看有哪些表
hbase(main)> list
2）创建表
 
# 语法：create <table>, {NAME => <family&g
      

      • 

    • C语言scanf继续学习、算术运算符学习和逻辑运算符
dcj3sjt126com
c

      /*
2013年3月11日20:37:32
地点：北京潘家园
功能：完成用户格式化输入多个值
目的：学习scanf函数的使用
*/
# include <stdio.h>
int main(void)
{
int i, j, k;
printf("please input three number:\n"); //提示用
      

      • 

    • 2015越来越好
dcj3sjt126com
歌曲

      越来越好
房子大了电话小了 感觉越来越好
假期多了收入高了 工作越来越好
商品精了价格活了 心情越来越好
天更蓝了水更清了 环境越来越好
活得有奔头人会步步高
想做到你要努力去做到
幸福的笑容天天挂眉梢 越来越好
婆媳和了家庭暖了 生活越来越好
孩子高了懂事多了 学习越来越好
朋友多了心相通了 大家越来越好
道路宽了心气顺了 日子越来越好
活的有精神人就不显
      

      • 

    • java.sql.SQLException: Value '0000-00-00' can not be represented as java.sql.Tim
feiteyizu
mysql

      数据表中有记录的time字段（属性为timestamp）其值为：“0000-00-00 00:00:00”
程序使用select 语句从中取数据时出现以下异常：
java.sql.SQLException:Value '0000-00-00' can not be represented as java.sql.Date
 
java.sql.SQLException: Valu
      

      • 

    • Ehcache（07）——Ehcache对并发的支持
234390216
并发ehcache锁ReadLockWriteLock

      Ehcache对并发的支持
 
       在高并发的情况下，使用Ehcache缓存时，由于并发的读与写，我们读的数据有可能是错误的，我们写的数据也有可能意外的被覆盖。所幸的是Ehcache为我们提供了针对于缓存元素Key的Read（读）、Write（写）锁。当一个线程获取了某一Key的Read锁之后，其它线程获取针对于同
      

      • 

    • mysql中blob,text字段的合成索引
jackyrong
mysql

        在mysql中，原来有一个叫合成索引的，可以提高blob,text字段的效率性能，
但只能用在精确查询，核心是增加一个列，然后可以用md5进行散列，用散列值查找
则速度快
比如：
create table abc(id varchar(10),context blog,hash_value varchar(40));
insert into abc(1,rep
      

      • 

    • 逻辑运算与移位运算
latty
位运算逻辑运算

      源码：正数的补码与原码相同例+7 源码：00000111 补码 ：00000111 （用8位二进制表示一个数）
负数的补码：
符号位为1，其余位为该数绝对值的原码按位取反；然后整个数加1。   -7 源码： 10000111 ，其绝对值为00000111  取反加一：11111001 为-7补码
已知一个数的补码，求原码的操作分两种情况：
      

      • 

    • 利用XSD 验证XML文件
newerdragon
javaxmlxsd

      XSD文件 （XML Schema 语言也称作 XML Schema 定义（XML Schema Definition，XSD）。 具体使用方法和定义请参看：
http://www.w3school.com.cn/schema/index.asp
java自jdk1.5以上新增了SchemaFactory类 可以实现对XSD验证的支持，使用起来也很方便。
以下代码可用在J
      

      • 

    • 搭建 CentOS 6 服务器(12) - Samba
rensanning
centos

      （1）安装
# yum -y install samba
Installed:
samba.i686 0:3.6.9-169.el6_5
# pdbedit -a rensn
new password:123456
retype new password:123456
……
（2）Home文件夹
# mkdir /etc
      

      • 

    • Learn Nodejs 01
toknowme
nodejs

      （1）下载nodejs
https://nodejs.org/download/ 选择相应的版本进行下载     （2）安装nodejs 安装的方式比较多，请baidu下
我这边下载的是“node-v0.12.7-linux-x64.tar.gz”这个版本 （1）上传服务器 （2）解压 tar -zxvf  node-v0.12.
      

      • 

    • jquery控制自动刷新的代码举例
xp9802
jquery

      1、html内容部分  复制代码代码示例: <div id='log_reload'>
<select name="id_s" size="1">
<option value='2'>-2s-</option>
<option value='3'>-3s-</option
      

      •