<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[sleepingposture的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/sleepingposture</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; sleepingposture]]></copyright><item><title><![CDATA[ArrayList和CopyOnWriteArrayList使用iterator迭代器出现的一些问题]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/115497646</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/115497646</guid><author>sleepingposture</author><pubDate>Wed, 07 Apr 2021 22:16:42 +0800</pubDate><description><![CDATA[看源码突然发现一个神奇的地方，关于线程不安全的ArrayList和线程安全的CopyOnWriteArrayList使用iterator迭代器出现的一些问题。
ArrayList的分析
我们知道ArrayList是线程不安全的集合类，但是在单线程环境下，使用iterator进行遍历修改的时候会出现 java.util.ConcurrentModificationException并发修改异常，这是为什么呢？
原来是由于ArrayList实现了fail-fast机制，什么是fail-fast机制呢？
如果当一]]></description><category></category></item><item><title><![CDATA[单例模式的几种实现方式]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/115111478</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/115111478</guid><author>sleepingposture</author><pubDate>Tue, 23 Mar 2021 10:25:02 +0800</pubDate><description><![CDATA[import java.util.Random;

public class Test{
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        System.out.println(instance);
        Singleton instance2 = Singleton.getInstance();
        System.out.]]></description><category></category></item><item><title><![CDATA[HashMap源码分析（逐句解析）]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/114703281</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/114703281</guid><author>sleepingposture</author><pubDate>Fri, 12 Mar 2021 19:31:35 +0800</pubDate><description><![CDATA[今天学习了HashMap的源码分析，然后自己跟着源码走了一遍，写了一些总结，嘿嘿。
核心属性分析
既然要学习HashMap，那我们肯定要知道他有哪些属性，不然方法就更看不懂了。推荐可以看一下这一篇博客：https://blog.youkuaiyun.com/fan2012huan/article/details/51087722，通过反射进行测试，可以更好的理解属性的意义。重要属性如下：
//HashMap核心属性分析
    //默认数组容量大小为16
    static final int DEFAULT_INI]]></description><category></category></item><item><title><![CDATA[ArrayList及LinkedList源码分析]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/114415612</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/114415612</guid><author>sleepingposture</author><pubDate>Fri, 05 Mar 2021 21:54:22 +0800</pubDate><description><![CDATA[jdk7的情况

利用无参构造ArrayList list = new ArrayList()；创建一个ArrayList会在底层创建一个长度为10的Object数组；
调用add方法之后，list.add(123)之后直接将ObjectArray[0]=new Integer(123);
当添加元素超过10之后，例如添加第十一个元素，此时数组容量不够需要进行扩容操作，数组会扩容为原始数组长度的1.5倍，同时需要将原有数组的数据复制到新的数组中。

建议在开发中使用带参数的构造器：ArrayList lis]]></description><category></category></item><item><title><![CDATA[Spring中Bean的生命周期]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/114377555</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/114377555</guid><author>sleepingposture</author><pubDate>Thu, 04 Mar 2021 21:20:21 +0800</pubDate><description><![CDATA[Spring中Bean的生命周期实例
Spring中Bean的生命周期大致分为如下几步：
1、通过构造器创建Bean实例
2、调用set函数对Bean完成属性的填充以及对其他bean的引用
3、调用bean实例的初始化方法
4、此时已经可以获取bean对象，可以使用了
5、关闭容器后，调用bean实例的初始化方法
实例演示

首先导入Spring的依赖以及Junit依赖

&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;project xmlns="http]]></description><category></category></item><item><title><![CDATA[论文-Catch22：Canonical Time-series Characteristics（规范时间序列特征）]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/106780947</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/106780947</guid><author>sleepingposture</author><pubDate>Tue, 16 Jun 2020 10:05:51 +0800</pubDate><description><![CDATA[一、论文主要工作总结

在这项工作中，介绍了一种时间序列特征的小集合的方法，该方法（i）在给定的时间序列问题集合中表现出强大的分类性能，并且（ii）具有最小的冗余性。

将该方法应用于93个时间序列分类数据集（包含超过147,000个时间序列），并使用hctsa特征库的过滤版本（4791个特征），引入了22个规范的时间序列特征，catch22可以适合时间序列数据挖掘任务中通常遇到的动态变化。尽管将分类精度平均降低了7％，但从4791降到22的降维与计算时间减少了约1000倍，并且时间随时间序列长度的变化接近]]></description><category></category></item><item><title><![CDATA[毕25-第七天（day12）-多线程（线程间通信）]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/106069489</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/106069489</guid><author>sleepingposture</author><pubDate>Tue, 12 May 2020 16:32:01 +0800</pubDate><description><![CDATA[线程间通信
	
线程间通信其实就是多个线程在操作同一个资源，但是操作的动作不同，下面需要实现一个需求：有一个输入操作和一个输出操作，一边向缓冲区中存数据，一遍从缓冲区中取数据：


class Res{
	String name;
	String sex;
}

class Input implements Runnable{
	private Res r;
	Input(Res r){
		this.r = r;
	}
	public void run() {
		int x = 0;
		while..]]></description><category></category></item><item><title><![CDATA[毕25-第六天（day11）-多线程]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/106055398</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/106055398</guid><author>sleepingposture</author><pubDate>Mon, 11 May 2020 22:43:34 +0800</pubDate><description><![CDATA[多线程创建及运行
	
进程是一个正在执行的程序，每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

线程就是进程中的一个独立的控制单元，线程在控制着进程的执行。

一个进程中至少有一个线程。

JavaVM启动的时候会有一个进程java.exe，该进程中至少有一个线程负责Java程序的执行，而且这个线程运行的代码存在于main方法中，该线程称之为主线程。

扩展：其实更细节的说，jvm启动的不止一个线程，还有负责垃圾回收机制的线程。

Java已经提供了对线程这类事物的描述，即..]]></description><category></category></item><item><title><![CDATA[毕25-第五天（day10）-面向对象（异常）]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/106041201</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/106041201</guid><author>sleepingposture</author><pubDate>Sun, 10 May 2020 23:27:45 +0800</pubDate><description><![CDATA[finally关键字
	
在下面的例子中，finally中语句，以及后面的输出over语句都执行了：


class FuShuException extends Exception{
	FuShuException(String msg){
		super(msg);
	}
}

class Demo{
	int div(int a,int b)throws FuShuException{
		if(b&lt;0) {
			throw new FuShuException("除数为负数");
		}..]]></description><category></category></item><item><title><![CDATA[毕25-第四天（day09）-面向对象（异常）]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/106021232</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/106021232</guid><author>sleepingposture</author><pubDate>Sat, 09 May 2020 22:19:24 +0800</pubDate><description><![CDATA[异常概述
	
异常就是程序在运行时出现的不正常情况。

异常的由来：出现问题是现实生活中一个具体的事物，所以可以通过Java的类来描述，并封装为对象。所以异常就是Java对于不正常情况进行描述后的对象体现。如下面的除零操作：


class Demo{
	int div(int a,int b) {
		return a/b;
	}
}

class Test{
	public static void main(String[] args) {
		Demo d = new Demo();
		d.di..]]></description><category></category></item><item><title><![CDATA[毕25-第三天（day09）-面向对象（内部类）]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/106002042</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/106002042</guid><author>sleepingposture</author><pubDate>Fri, 08 May 2020 23:58:29 +0800</pubDate><description><![CDATA[内部类访问规则
	
内部类的访问规则：

1、内部类可以直接访问外部类中的成员，包括私有成员。之所以可以直接访问外部类中的成员，是因为内部类持有了一个外部类的引用，格式为：外部类名.this。

2、外部类要访问内部类，必须建立内部类对象。

看如下案例：


class Outer{
	private int x = 3;
	class Inner{
		void function() {
			System.out.println("inner:"+x);
		}
	}
	void method()..]]></description><category></category></item><item><title><![CDATA[毕25-第二天（day08）-面向对象（多态）]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/105980017</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/105980017</guid><author>sleepingposture</author><pubDate>Thu, 07 May 2020 22:10:25 +0800</pubDate><description><![CDATA[多态的扩展性
	
假设有如下几个类：


abstract class Animal{
	abstract void eat();
}

class Cat extends Animal{
	public void eat() {
		System.out.println("吃鱼");
	}
	public void catchMouse() {
		System.out.println("抓...]]></description><category></category></item><item><title><![CDATA[毕25-第二天（day07）-面向对象（继承与接口）]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/105965585</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/105965585</guid><author>sleepingposture</author><pubDate>Thu, 07 May 2020 14:00:34 +0800</pubDate><description><![CDATA[继承
	
在下面的例子中有两个类，Student、Worker。


class Student{
    String name;
    int age;
    void study(){
        System.out.println("study");
    }
}

class Worker{
    String name;
    int age;
    void w...]]></description><category></category></item><item><title><![CDATA[毕25-第一天（day06）-面向对象（设计模式之单例设计模式）]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/105958153</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/105958153</guid><author>sleepingposture</author><pubDate>Wed, 06 May 2020 21:21:54 +0800</pubDate><description><![CDATA[单例设计模式
	
设计模式：解决某一问题最行之有效的方法。Java中有23种设计模式。

单例设计模式：解决一个类在内存中只存在一个对象。

想要保证对象唯一，有如下要求：

1、为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象；

2、还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象；

3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三个要...]]></description><category></category></item><item><title><![CDATA[毕25-第一天（day06）-面向对象]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/105953622</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/105953622</guid><author>sleepingposture</author><pubDate>Wed, 06 May 2020 20:09:59 +0800</pubDate><description><![CDATA[static关键字
	
static是一个静态的修饰符，用于修饰成员（成员变量、成员函数）。当成员被静态修饰后，就多了一个调用方式，除了可以使用对象调用，还可以直接被类名调用，类名.静态成员。


class Person
{
	String name;    //实例变量，或成员变量
	static String country = "CN";    //静态成员变量，或类变量
	publi...]]></description><category></category></item><item><title><![CDATA[毕25第一天-面向对象]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/105945263</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/105945263</guid><author>sleepingposture</author><pubDate>Wed, 06 May 2020 12:18:30 +0800</pubDate><description><![CDATA[面向对象与面向过程的区别
	
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向对象是把构成问题的事物分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

直观的例子：人开门。

面向过程思想：1、打开门；2、关闭门。

面向对象思想：将人和门分为两个对象，每个对象有不同的方...]]></description><category></category></item><item><title><![CDATA[Java学习路线大纲]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/105937221</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/105937221</guid><author>sleepingposture</author><pubDate>Tue, 05 May 2020 19:19:42 +0800</pubDate><description><![CDATA[一、Java基础课程
1）Java基础课程内容涉及：Java开发介绍、Java数组、Java面向对象、常用基础类、集合、IO流、多线程、异常、网络、反射。

&nbsp;
第一阶段：Java基...]]></description><category></category></item><item><title><![CDATA[Java——方法的参数总是使用值传递]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/105922545</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/105922545</guid><author>sleepingposture</author><pubDate>Mon, 04 May 2020 21:05:21 +0800</pubDate><description><![CDATA[在C语言中函数的参数有值传递方式以及地址传递方式两种，但是在Java中只有值传递这一种方式。

案例一：

在下面的例子中执行将a乘以3


int a = 10;
three_a(a);

方法three_a()的部分如下：


public static void three_a(int x)
{
    x = x*3;
}

将a传入方法中，经过调用three_a()方法之后，首先x=10...]]></description><category></category></item><item><title><![CDATA[Java——不规则多维数组的构建]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/105907293</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/105907293</guid><author>sleepingposture</author><pubDate>Sun, 03 May 2020 19:21:16 +0800</pubDate><description><![CDATA[普通多维数组的构建相对来说都是规则的，比如定义一个二维数组：int[][] a = new int[10][5]，这个数组是一个10行5列的二维数组。

上述构建的二维数组是每行的列数都是相同的，但是对于想构建每一行的列数有所不同的数组，则需要其他的定义方式。

在Java中，实际上没有多维数组，只有一维数组，多维数组称为“数组的数组”；对于一个二维数组来说，首先把它看作一维数组，这个一维数组中的...]]></description><category></category></item><item><title><![CDATA[加油丫✌]]></title><link>https://blog.youkuaiyun.com/sleepingposture/article/details/105108649</link><guid>https://blog.youkuaiyun.com/sleepingposture/article/details/105108649</guid><author>sleepingposture</author><pubDate>Thu, 26 Mar 2020 00:21:23 +0800</pubDate><description><![CDATA[重度拖延症患者，醒过来吧，加油吧，啊啊啊啊，没什么好玩的，还是学习好玩啊！

加油✌
]]></description><category></category></item></channel></rss>