<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[wcs_csdn的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/wcs_csdn</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; wcs_csdn]]></copyright><item><title><![CDATA[Stream流]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/120355500</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/120355500</guid><author>wcs_csdn</author><pubDate>Fri, 17 Sep 2021 19:41:23 +0800</pubDate><description><![CDATA[package com.wcs.demo2;
 
import java.util.ArrayList;
import java.util.stream.Stream;

/**
* Stream流中的常用方法
 */
public class StreamTest03 {
    public static void main(String[] args) {
        //forEach方法，用来遍历流中的数据
        //是一个终结方法，遍历之后就不能继续调用Stream流中的其他方法
]]></description><category></category></item><item><title><![CDATA[Lambada表达式]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/120328346</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/120328346</guid><author>wcs_csdn</author><pubDate>Thu, 16 Sep 2021 14:34:57 +0800</pubDate><description><![CDATA[package com.wcs.demo1;


/**
 * 不使用Lambda表达式
 */
public class MyRunable {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        MyRunableImpl run = new MyRunableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类
        Thread ]]></description><category></category></item><item><title><![CDATA[Java注解]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/120313323</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/120313323</guid><author>wcs_csdn</author><pubDate>Wed, 15 Sep 2021 17:28:59 +0800</pubDate><description><![CDATA[package com.wcs.annotation;

/**
 * 注解，或者叫做注释类型：Annotation
 * 注解Annotation是一种引用数据类型，编译之后也是生成class文件
 * 自定义注解
 * [修饰符列表] @interface 注解名{}
 */
public class AnnotationTest01 {
    @MyAnnotation
    private int no;

    @MyAnnotation
    public AnnotationTest0]]></description><category></category></item><item><title><![CDATA[反射机制概述]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/120275953</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/120275953</guid><author>wcs_csdn</author><pubDate>Mon, 13 Sep 2021 21:26:36 +0800</pubDate><description><![CDATA[1、反射机制概述
1.1、反射机制有什么用？
​	通过Java语言中的反射机制可以操作字节码文件（class文件）。
1.2、反射机制相关的类在哪个包下？
​	反射机制在java.lang.reflect.*包下。
1.3、反射机制相关的重要的类有哪些？
​	java.lang.class：代表整个字节码，代表一个类型。
​	java.lang.reflect.Method：代表字节码中的方法字节码。
​	java.lang.reflect.Constructor：代表字节码中的构造方法字节码。
​	jav]]></description><category></category></item><item><title><![CDATA[多线程概述]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/120220875</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/120220875</guid><author>wcs_csdn</author><pubDate>Fri, 10 Sep 2021 14:12:11 +0800</pubDate><description><![CDATA[1、线程概述
什么是进程？什么是线程？
​	进程是一个是一个应用程序（1个进程是一个软件）。
​	线程是一个进程中的执行场景\执行单元。
​	一个进程可以启动多个线程。
在Java语言中，线程A和线程B，堆内存和方法区共享。但是栈独立，一个线程一个栈。
假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。
Java中之所以有多线程机制，是为了提高程序的处理效率。
2、实现线程
Java语言中，实现线程有三种方式：
2.1 继承Thread
​	第一种：编写一]]></description><category></category></item><item><title><![CDATA[IO流概述]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/120187677</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/120187677</guid><author>wcs_csdn</author><pubDate>Wed, 08 Sep 2021 20:03:02 +0800</pubDate><description><![CDATA[什么是IO流？
​	I：Input
​	O：Output
通过IO可以完成硬盘文件的读和写。
IO流的分类？
有多种分类方式：
​	一种是按照流的方向分类：
​		往内存中去，叫做输入(Input)。或者叫做读(Read)。
​		从内存里出来，叫做输出(Output)。或者叫做写(Write)。
​	另一种是按照读取数据方式不同进行分类：
​		有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制。这种流是万能的，什么类型的文件都可以读取，包括：文本文件，图片，声音文件，视频]]></description><category></category></item><item><title><![CDATA[Map接口概述]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/120121555</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/120121555</guid><author>wcs_csdn</author><pubDate>Sun, 05 Sep 2021 21:16:45 +0800</pubDate><description><![CDATA[1 Map接口

Map和Collection没有继承关系
Map集合以key和value的方式存储数据：键值对
​	key和value都是引用数据类型。
​	key和value都是存储对象的内存地址。
​	key起主导作用，value是key的附属品。
Map接口中的常用方法：
V put(K key,V value);向Map集合中添加键值对
V get(Object key);通过Key获取value
void clear();清空Map集合
boolean containsKey(Object ke]]></description><category></category></item><item><title><![CDATA[自定义类型怎么实现Comparable接口]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/120100438</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/120100438</guid><author>wcs_csdn</author><pubDate>Sat, 04 Sep 2021 15:17:18 +0800</pubDate><description><![CDATA[自定义类型怎么实现Comparable接口
//年龄降序
import java.util.TreeSet;

public class ComTest01 {
    public static void main(String[] args) {
        TreeSet&lt;Person&gt; tr = new TreeSet&lt;&gt;();
        tr.add(new Person(12));
        tr.add(new Person(23));
        ]]></description><category></category></item><item><title><![CDATA[Java泛型机制]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/120084391</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/120084391</guid><author>wcs_csdn</author><pubDate>Fri, 03 Sep 2021 16:15:52 +0800</pubDate><description><![CDATA[JDK5.0之后推出新特性：泛型。
泛型这种语法机制，只在程序编译阶段起作用，只是给编译器参考的。（运行阶段泛型没用）
使用泛型的好处？
​	第一：集合中存储的元素类型统一了。
​	第二：从集合中取出元素类型是泛型指定的类型，不需要大量的”向下转型“。
泛型的缺点：导致集合中存储的元素缺乏多样性。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 *未使用泛型
 * 从集合中取出元素需要进行]]></description><category></category></item><item><title><![CDATA[Set接口]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/120049400</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/120049400</guid><author>wcs_csdn</author><pubDate>Wed, 01 Sep 2021 21:31:44 +0800</pubDate><description><![CDATA[1 Set接口
1.1 HashSet
哈希表是一种数据结构，哈希表能够提供快速存取操作。哈希表是基于数组的，所以也存在缺点，数组一旦创建将不能扩展。
HashSet 中的数据是无序的不可重复的。HashSet 按照哈希算法存取数据的，具有非常好性能， 它的工作原理是这样的，当向 HashSet 中插入数据的时候，他会调用对象的 hashCode 得到该对象的哈希码，然后根据哈希码计算出该对象插入到集合中的位置.
1.1.1 HashSet集合操作
import java.util.HashSet;
imp]]></description><category></category></item><item><title><![CDATA[List接口]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/120019828</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/120019828</guid><author>wcs_csdn</author><pubDate>Tue, 31 Aug 2021 15:49:53 +0800</pubDate><description><![CDATA[List 接口下面主要有两个实现ArrayList 和LinkedList，他们都是有顺序的，也就是放进去是什么顺序，取出来还是什么顺序，也就是基于线性存储，可以看作是一个可变数组
ArrayList：查询数据比较快，添加和删除数据比较慢(基于可变数组)
LinkedList：查询数据比较慢，添加和删除数据比较快（基于链表数据结构）
Vector:Vector 已经不建议使用，Vector 中的方法都是同步的，效率慢，已经被 ArrayList取代
Stack 是继承Vector 实现了一个栈，栈结构是后进]]></description><category></category></item><item><title><![CDATA[Collection接口概述]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/119997722</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/119997722</guid><author>wcs_csdn</author><pubDate>Mon, 30 Aug 2021 15:17:48 +0800</pubDate><description><![CDATA[1、Collection中能存放什么元素？
​	没有使用”泛型之前“，Collection中可以存储Object的所有子类型。
​	使用了泛型之后，Collection中只能存储某个具体的类型。

2、Collection中的常用方法
​	boolean add(Object e)；向集合中添加元素
​	int size();获取集合中元素的个数
​	void clear();清空集合
​	boolean contains(Object o);判断集合中是否包含元素…
​	boolean remove(Ob]]></description><category></category></item><item><title><![CDATA[Java异常]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/119982441</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/119982441</guid><author>wcs_csdn</author><pubDate>Sun, 29 Aug 2021 16:54:05 +0800</pubDate><description><![CDATA[1 异常的基本概念
什么是异常，在程序运行过程中出现的错误，称为异常。
int a = 10;
int b = 0;
int c = a / b;
//error：ArithmeticException
System.out.println(c);

Java给我们提供了这样一个体系结构，当出现问题的时候，它会告诉我们，并且把错误的详细信息也告诉我们了，这就是异常的体系结构，这样我们的程序更健壮，我们可以把这个信息，再进行处理以下告诉用户。
public class ExceptionTest02 {
  ]]></description><category></category></item><item><title><![CDATA[枚举数据类型]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/119967061</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/119967061</guid><author>wcs_csdn</author><pubDate>Sat, 28 Aug 2021 13:32:57 +0800</pubDate><description><![CDATA[枚举编译之后也是生成class文件。
枚举也是一种引用数据类型。
枚举语法：
​	enum 枚举类型名{
​		枚举值1，枚举值2
}
结果只有两种情况的，建议使用布尔类型。
结果超过两种并且还是可以一枚一枚例举出来的，建议使用枚举类型。
public class EnumTest01 {
    public static void main(String[] args) {
       Result r = divide(10,2);
        System.out.println(r == R]]></description><category></category></item><item><title><![CDATA[基本数据类型对应的8个包装类]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/119936707</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/119936707</guid><author>wcs_csdn</author><pubDate>Thu, 26 Aug 2021 17:35:15 +0800</pubDate><description><![CDATA[Java中为8中数据类型准备了8中对应的包装类型，是属于引用类型，父类是Object。
以Integer为例
public class IntegerTest01 {
    public static void main(String[] args) {
        Integer integer = 12;
        sum(12);
    }

    public static void sum(Object obj) {
        System.out.println(obj);]]></description><category></category></item><item><title><![CDATA[StringBuffer]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/119907303</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/119907303</guid><author>wcs_csdn</author><pubDate>Wed, 25 Aug 2021 11:23:58 +0800</pubDate><description><![CDATA[因为Java字符串是不可变的，每一次拼接都会产生新的字符串，这样会占用大量的方法区内存，造成内存空间的浪费。
String s = "abc";
s += "hello";
//以上两行代码就导致在方法区字符串常量池中创建了3个对象
//"abc" "hello" "abchello"

如果以后需要大量字符串拼接的工作，建议使用StringBuffer、StringBuilder。
StringBuffer 称为字符串缓冲区，它的工作原理是：预先申请一块内存，存放字符序列，如果字符序列满了，会重新改变缓存]]></description><category></category></item><item><title><![CDATA[String类]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/119889572</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/119889572</guid><author>wcs_csdn</author><pubDate>Tue, 24 Aug 2021 14:39:21 +0800</pubDate><description><![CDATA[String表示字符串，属于引用数据类型，不属于基本数据类型；
在Java中使用双引号括起来的都是String对象，是不可变的；
使用双引号括起来的字符串，都是直接存储在“方法区”的“字符串常量池”中，因为字符型在实际开发中使用太频繁，为了执行效率所以把字符串放到了字符串常量池当中；

//在字符串常量池中有三个字符串
String s1 = "abcd";
String s2 = "xyz" + "mn";

String s1 = "hello";
//"hello"是存储在方法区的字符串常量池当中
.]]></description><category></category></item><item><title><![CDATA[匿名内部类]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/119868203</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/119868203</guid><author>wcs_csdn</author><pubDate>Mon, 23 Aug 2021 14:12:36 +0800</pubDate><description><![CDATA[内部类概述
什么是内部类？
​	在类的内部又定义了一个新的类。被称为内部类。
内部类的分类：
​	静态内部类：类似于静态变量
​	实例内部类：类似于实例变量
​	局部内部类：类似于局部变量
public class ClassTest {
    //这些类在类的内部，所以被称为内部类
    //静态内部类
    static class Inner1 {
    }

    //实例内部类
    class Inner2 {
    }

    public void test() {
    ]]></description><category></category></item><item><title><![CDATA[Object类]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/119854284</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/119854284</guid><author>wcs_csdn</author><pubDate>Sun, 22 Aug 2021 16:31:42 +0800</pubDate><description><![CDATA[任何一个类默认继承Object。就算没有直接继承，最终也会间接继承。
什么是API?
应用程序编程接口。整个jdk的类库就是一个JavaSE的API。
每个API都会配置一套API帮助文档。
toString()方法
toString()方法的默认实现是：类名@对象的内存地址转换为十六进制的形式。
toString()方法的作用是通过调用这个方法可以将一个Java对象转换成字符串形式。
public class ToStringTest {
    public static void main(Strin]]></description><category></category></item><item><title><![CDATA[访问控制权限]]></title><link>https://blog.youkuaiyun.com/wcs_csdn/article/details/119835907</link><guid>https://blog.youkuaiyun.com/wcs_csdn/article/details/119835907</guid><author>wcs_csdn</author><pubDate>Sat, 21 Aug 2021 10:10:00 +0800</pubDate><description><![CDATA[访问控制权限有哪些？
private 私有的
protected受保护的
public公共的
默认
以上4个访问控制权限：控制范围是什么？

​	private 表示私有的，只能在本类中访问
​	public 表示公开的，在哪里都可以访问
public class User {
    //私有的 只能在本类中访问
    private String name;
    //受保护的
    protected int age;
    //公共的
    public int id;
}

class ]]></description><category></category></item></channel></rss>