JavaSE笔记

最新推荐文章于 2024-11-09 12:43:52 发布

金州_拉文

最新推荐文章于 2024-11-09 12:43:52 发布

阅读量216

点赞数

分类专栏： javase 文章标签： java

本文链接：https://blog.csdn.net/qq_45556218/article/details/107295961

版权

javase 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一：递归

在这里插入图片描述
案例

package com.hp;

import java.io.File;

/**
 * @author SX
 * @date 2020/7/12 -10:23
 */
public class Recursive {
    /**
     * 递归求和 1---n
     */
    public static void main(String[] args) {
     /*   int s=a(3);
        System.out.println(s);*/
        File f = new File("C:\\Users\\SX\\Desktop\\库里");
        getAllfile(f);
    }

    /**
     * 搜索指定文件后缀的 根据递归
     * @param dir
     */
    private static void getAllfile(File dir) {
        File[] files = dir.listFiles();
        for (File f : files) {
            if (f.isDirectory()) {
                getAllfile(f);     //递归遍历这个文件夹
            } else {
               if(f.getName().toLowerCase().endsWith(".jpg")){    //.toLowerCase()转为小写
                   System.out.println(f);                        //endwith截取末尾的字符串
               }
            }
        }

    }

    /**
     * 1-3的和
     *
     * @param n
     * @return
     */
    private static int a(int n) {
        if (n == 1) {
            return 1;
        }
        return n + a(n - 1);
    }
}

//.toLowerCase()转为小写
//endwith截取末尾的字符串
listFiles()和list区别：
listFiles 返回表示抽象路径名的目录中的文件的路径名表示抽象的数组。
list 返回的字符串在该目录下的抽象路径名的文件和目录命名为数组。

二：基本数据类型

在这里插入图片描述

三：集合

在这里插入图片描述

四：泛型

在这里插入图片描述

五：数据结构

在这里插入图片描述

eg HasSet

package com.hp.HasSet;

import java.util.HashSet;
import java.util.Set;

/**
 * @author SX
 * @date 2020/7/17 -15:36
 */
public class HasSetDemo {
    public static void main(String[] args) {
        show();
    }

    private static void show() {
        //HasSet是Set的子类   无序不能存储重复的元素
        HashSet<String> hashSet = new HashSet<String>();
          hashSet.add("你好1");
        hashSet.add("你好1");
        hashSet.add("你好2");
        hashSet.add("你好2");
        System.out.println(hashSet);
     //个人理解：不能存储重复元素原理：每一次add都会判断是否哈希值相等
        //并且进行 equla判断视口相等
        //当都为true  就是同一个元素  不添加
    }
}

自定义HasSet(必须在泛型实体类中加上hashCode（）和equals（）方法)

package com.hp.CustomizeHasSet;

import java.util.HashSet;

/**
 * @author SX
 * @date 2020/7/17 -15:55
 */
public class TestDemo {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setUname("小红");
        p1.setAge(18);
        Person p2 = new Person();
        p2.setUname("小红");
        p2.setAge(18);
        Person p3 = new Person();
        p3.setUname("小红");
        p3.setAge(17);
        HashSet<Person> hashSet = new HashSet<>();
        hashSet.add(p1);
        hashSet.add(p2);
        hashSet.add(p3);

        System.out.println(
                hashSet
        );   //[Person{Uname='小红', Age=18}, Person{Uname='小红', Age=18}],[Person{Uname='小红', Age=17}
        //当在实体类进行  hascode 和equals()时就不能存储重复元素
        //打印结果为  [Person{Uname='小红', Age=17}, Person{Uname='小红', Age=18}]

    }
}

LinkList eg

package com.hp.LinkList;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * @author SX
 * @date 2020/7/17 -12:46
 *
 *
 * 不能使用多态创建  因为 多态只能使用父类方法无法查看子类方法
 */
public class LinkListDemo {

    public static void main(String[] args) {
        show();
    }

    private static void show() {
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("你好1");
        linkedList.add("你好2");
        linkedList.add("你好3");
        linkedList.add("你好4");
        System.out.println(linkedList);
        //首尾加上新的元素   addfirst   addlast
        linkedList.addFirst("我是首部");
        linkedList.addLast("我是尾部");
        System.out.println(linkedList);
       //删除 首尾元素   removeFirst();    removeLast();
        linkedList.removeFirst();
        linkedList.removeLast();
        System.out.println(linkedList);

    }
}

LinkHasSet eg

package com.hp.LinkHasSet;

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;

/**
 * @author SX
 * @date 2020/7/17 -16:04
 *
 * 特点：有序  但是 也不能储存相同的元素
 */
public class DemoLinkHasSet {

    public static void main(String[] args) {
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("1");
        linkedHashSet.add("2");
        linkedHashSet.add("3");
        linkedHashSet.add("4");
        System.out.println(linkedHashSet);
        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        for (Integer integer : list) {
            System.out.println(integer);
        }

    }
}

六：可变参数

在这里插入图片描述

eg

package com.hp.variableParameter;

/**
 * @author SX
 * @date 2020/7/18 -0:02
 */
public class Demoparameter {
//可变参数
    public static void main(String[] args) {
        int i=show(1,2,3,4,5,6,7,8,9,10);
        System.out.println(i);
    }
   //。。
    private static int  show(int ...array) {
        int sum=0;
        for (int i : array) {
            sum+=i;
        }
        return sum;
    }
}

七：集合的工具类

	![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/ae362a06ed88b193534d136bd07291ad.jpeg)

在这里插入图片描述

eg

package com.hp.collectionTools;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

/**
 * @author SX
 * @date 2020/7/18 -0:10
 */
public class Democollection {
    public static void main(String[] args) {
        ArrayList<String> collection=new ArrayList<>();
        //static  工具类  故可以直接通过类名.方法名进行 调用
        Collections.addAll(collection,"f","b","c");
        System.out.println(collection);
        //sort进行排序
        Collections.sort(collection);
        System.out.println(collection);
    }
}

八：Map集合

![在这里插入图片描述](https://img-blog.csdnimg.cn/20200718133053496.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTU2MjE4,size_16,color_FFFFFF,t_70)

在这里插入图片描述

eg使用Map.Entry遍历Map集合

package com.hp.Map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * @author SX
 * @date 2020/7/18 -12:31
 *
 * 使用Map.Entry遍历Map集合
 */

public class DemoHashMapEntry {
    public static void main(String[] args) {
        show();
    }

    private static void show() {
        Map<Integer, String> map = new HashMap<>();
        map.put(30, "库里");
        map.put(24, "科比");
        map.put(23, "詹姆斯");
        map.put(23, "乔丹");
        Set<Map.Entry<Integer, String>> player = map.entrySet();
        Iterator<Map.Entry<Integer, String>> iterator = player.iterator();
        while(iterator.hasNext()){
            Map.Entry<Integer, String> value = iterator.next();
            Integer number = value.getKey();
            String name = value.getValue();
            System.out.println("使用EntrySet遍历的"+number+"："+name);

        }
    }
}

###　使用迭代器遍历

package com.hp.Map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * @author SX
 * @date 2020/7/18 -11:54
 */
public class DemoHashMapKeySet {
    public static void main(String[] args) {
        /*   show();*/
        show2();
    }

    private static void show2() {
        Map<Integer, String> map = new HashMap<>();
        map.put(30, "库里");
        map.put(24, "科比");
        map.put(23, "詹姆斯");
        map.put(23, "乔丹");
        //使用keySet 增强for循环遍历  指定Map集合
        Set<Integer> integers = map.keySet();
        for (Integer key : integers) {
            String value = map.get(key);
            System.out.println("增强for循环遍历" + key + ":" + value);
        }


    }

    private static void show() {
        Map<Integer, String> map = new HashMap<>();
        map.put(30, "库里");
        map.put(24, "科比");
        map.put(23, "詹姆斯");
        map.put(23, "乔丹");
        System.out.println(map);
        //根据Key 来获取 Value
        String s = map.get(30);
        System.out.println(s);
        //删除指定key的map集合  map.remove(30);
        //使用KeySet遍历Map集合
        //迭代器遍历
        Set<Integer> integers = map.keySet();
        Iterator<Integer> iterator = integers.iterator();
        while (iterator.hasNext()) {
            Integer next = iterator.next();
            String value = map.get(next);
            System.out.println("迭代器遍历：" + next + ":" + value);
        }
    }
}

eg 实现计算字符串案例

package com.hp.Map;

import java.util.*;

/**
 * @author SX
 * @date 2020/7/18 -13:17
 */
public class Demopractice {

    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入个字符串");
        String str = scanner.next();
        Map<Character,Integer> map=new HashMap<>();
        //遍历字符串
        for(char c:str.toCharArray()){
           //判断字符在map集合中是否存在
            if(map.get(c)==null){
                //不存在
                map.put(c,1);
            }else {
                //存在
                Integer count = map.get(c);
                count++;
                map.put(c,count);
            }
        }
        Set<Character> characters = map.keySet();
        Iterator<Character> iterator = characters.iterator();
        while(iterator.hasNext()){
            Character next = iterator.next();
            Integer integer = map.get(next);
            System.out.println(next+"="+integer);
        }

    }

}

九：异常处理

在这里插入图片描述

eg:自定义异常类

package com.hp.customException;

/**
 * @author SX
 * @date 2020/7/20 -16:23
 */
public class LoginException  extends Exception{
    public LoginException(){
        super();
    }
    public LoginException(String name){
        super(name);
    }
}

十：字节输出输入流

在这里插入图片描述

eg 例子复制图片

package com.hp.copyFiles;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author SX
 * @date 2020/7/20 -23:07
 */
public class DemocopyFile {
    public static void main(String[] args) throws IOException {
        long s=System.currentTimeMillis();
        FileInputStream fis=new FileInputStream("C:\\Users\\SX\\Desktop\\zhaiShop\\GSlogo.jpg");
        FileOutputStream fos=new FileOutputStream("C:\\Users\\SX\\Desktop\\sc\\GSlogo1.jpg");
        //使用缓冲bytes
        byte[] bytes=new byte[1024*1000];
        int len=0;  //计算有效读取长度
        while((len=(fis.read(bytes)))!=-1){
            //使用字节输出流中的方法write把读取的字节写入到指定文件夹
            fos.write(bytes,0,len);
        }
        fis.close();
        fos.close();
        long e=System.currentTimeMillis();
        System.out.println("复制文件共耗时"+(e-s)+"毫秒");
    }

}

十一字符输出输入流

在这里插入图片描述

eg 输入流

package com.hp.CharacterOutputAndInputStream;

import java.io.FileReader;
import java.io.IOException;

/**
 * @author SX
 * @date 2020/7/21 -11:41
 */
public class DemoFileRead {
    public static void main(String[] args) throws IOException {
        FileReader fileReader=new FileReader("javase2020-07-20\\a.text");
        int len=0;
        char[] chars=new char[1024];
        while ((len=fileReader.read(chars))!=-1){
            System.out.println(new String(chars,0,len));
        }
        fileReader.close();


    }
}

eg 字符输出流

package com.hp.CharacterOutputAndInputStream;

import java.io.FileWriter;
import java.io.IOException;

/**
 * @author SX
 * @date 2020/7/21 -11:49
 */
public class DemoFileWrite {
    public static void main(String[] args) throws IOException {
        FileWriter fileWriter=new FileWriter("javase2020-07-21\\a.text");
        fileWriter.write(97);
        fileWriter.close();
    }
}

十二 Properties集合

在这里插入图片描述

eg存取

package com.hp.Properties;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

/**
 * @author SX
 * @date 2020/7/22 -12:00
 */
public class DemoProperties {
    public static void main(String[] args) throws IOException {
        Properties pro=new Properties();
        pro.setProperty("库里","30");
        pro.setProperty("科比","24");
        pro.setProperty("詹姆斯","23");
        //遍历集合
        Set<String> set = pro.stringPropertyNames();
        for (String s : set) {
            String value = pro.getProperty(s);
            System.out.println(s+"="+value);
        }
        //把你储存到硬盘上
        pro.store(new FileWriter("javase2020-07-22/a.text"),"save");

    }
}

eg 读取

package com.hp.Properties;

import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

/**
 * @author SX
 * @date 2020/7/22 -12:11
 */
public class DemoPropertiesLoad {
    public static void main(String[] args) throws IOException {
        Properties properties=new Properties();
        //load方法读取properties
        properties.load(new FileReader("javase2020-07-22/a.text"));
        Set<String> set = properties.stringPropertyNames();
        for (String s : set) {
            String var = properties.getProperty(s);
            System.out.println(s+"："+var);
        }
    }
}

字符缓冲输出/输出流

在这里插入图片描述

eg BufferedWriter

package com.hp.CharacterBufferStream;

import java.io.*;

/**
 * @author SX
 * @date 2020/7/22 -15:40
 */
public class DemoBufferWriter {
    public static void main(String[] args) throws IOException {
     BufferedWriter bfw=new BufferedWriter(new FileWriter("javase2020-07-22/BufferWriter.text"));
  for(int i=0;i<=9;i++){
      bfw.write("你好");
      bfw.newLine();  //换行
  }
  bfw.close();
    }
}

eg BufferedReader

package com.hp.CharacterBufferStream;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/**
 * @author SX
 * @date 2020/7/22 -16:15
 */
public class DemoBufferReader {
    public static void main(String[] args) throws IOException {
        BufferedReader bur=new BufferedReader(new FileReader("javase2020-07-22/BufferWriter.text"));
        String line;
        while((line=bur.readLine())!=null){
            System.out.println(line);
        }
        bur.close();
    }

}