Java知识点之杂记

最新推荐文章于 2024-09-21 10:38:43 发布
最新推荐文章于 2024-09-21 10:38:43 发布
阅读量184 收藏
点赞数
分类专栏： 杂记 知识点 Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_28370189/article/details/106936933
版权
杂记 同时被 3 个专栏收录
5 篇文章 0 订阅
订阅专栏
知识点
4 篇文章 0 订阅
订阅专栏
Java
4 篇文章 0 订阅
订阅专栏

这篇文章记录了一下Java知识点，后续会持续增加！~~~

 一、位运算中的与运算

package com;

/**
 * @author tzp
 * @created 2020年6月17日 下午7:28:52
 * @类描述：位运算中与运算（&），运用
 */
public class ANDOperation {

	public static void main(String[] args) {
		//判断奇偶性
		judgeOdevity(12);
	}
	
	/**
	 * @author tzp
	 * @created 2020年6月17日 下午7:43:31
	 * @param param
	 * @return
	 * @方法描述：判断奇偶性，偶数的二进制最低位为0，奇数的二进制最低位为1，判断过程如：a = 6 ---> 110, 1 ---> 001, 110 & 001 = 000 --->偶数
	 */
	public static void judgeOdevity(int a) {
		if((a & 1) == 1) {
			System.out.println("传递数据为奇数！");
		}
		if((a & 1) == 0) {
			System.out.println("传递数据为偶数！");
		}
	}

}

 二、位运算中的异或运算

package com;

/**
 * @author tzp
 * @created 2020年6月17日 下午3:10:47
 * @类描述：位运算中的异或运算（^），运用
 */
public class XOROperation {

	public static void main(String[] args) {
		//异或（^）实现数据交换
		swapData(10, 20);
	}
	
	/**
	 * @author tzp
	 * @created 2020年6月17日 下午3:13:26
	 * @param param
	 * @return
	 * @方法描述：交换两个变量的数值，不需要中间变量，异或运算
	 */
	public static void swapData(int a, int b) {
		System.out.println("交换前数据：" + a + ":" + b);
		a = a ^ b;
		b = a ^ b;
		a = a ^ b;
		System.out.println("交换后数据：" + a + ":" + b);
	}

}

 三、ArrayList、Vector元素可为空且可重复

package com;

import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

/**
 * @author tzp
 * @created 2020年6月15日 下午5:28:01
 * @类描述：ArrayList、Vector元素可为空且可重复
 */
public class ArrayListAndVectorCanNull {

	public static void main(String[] args) {
		List<String> strs = new ArrayList<>();
		strs.add(null);
		strs.add(null);
		System.out.println(strs);
		Vector<String> v = new Vector<>();
		v.add(null);
		v.add(null);
		System.out.println(v);
	}

}

 四、数组有最大长度限制？（不考虑空间大小）

package com;

/**
 * @author tzp
 * @created 2020年6月16日 下午2:48:33
 * @类描述：数组有最大长度限制？
 */
public class ArrayMaxLenth {
	
	/**
	 * @author tzp
	 * @created 2020年6月16日 下午7:59:32
	 * @param param
	 * @return
	 * @方法描述：可以看到数组的长度是有限制的，姑且认为大小不得超过Integer.MAX_VALUE，也就是2的16次幂。
	 */
	public static void main(String[] args) {
//		int[] len = new int[Integer.MAX_VALUE-1];//java.lang.OutOfMemoryError: Requested array size exceeds VM limit
		int[] len = new int[Integer.MAX_VALUE-2];//java.lang.OutOfMemoryError: Java heap space
		System.out.println("数组长度："+len.length);
	}
}

五、遍历集合元素时的fail-fast

package com;

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

/**
 * @author tzp
 * @created 2020年6月15日 下午5:29:14
 * @类描述：遍历过程中如果删除元素报ConcurrentModificationException错误-fail-fast
 */
public class FailFast {
	
	public static void main(String[] args) {
		List<String> strs = new ArrayList<>();
		strs.add("a");
		strs.add("b");
		strs.add("c");
		for(String str : strs) {
			System.out.println(str);
			strs.remove("b");
		}
	}
}

 六、查看CPU的数量

package com;

/**
 * @author tzp
 * @created 2020年6月24日 上午9:23:10
 * @类描述：查看CPU的数量
 */
public class CPUNumber {

	public static void main(String[] args) {
		System.out.println("CPU数量："+Runtime.getRuntime().availableProcessors());
	}

}

 七、排序之插入排序

package com.sort;

/**
 * @author tzp
 * @created 2020年6月22日 上午9:12:00
 * @类描述：插入排序
 */
public class InsertSort {

	public static void main(String[] args) {
		int[] arr = { 8, 3, 6, 9, 2, 1, 3 };
		insertSort(arr);
		print(arr);
	}

	/**
	 * @author tzp
	 * @created 2020年6月22日 上午10:30:59
	 * @param param
	 * @return
	 * @方法描述：主要逻辑：将元素插入到前面已经排好序的数组中
	 */
	public static void insertSort(int[] arr) {
		for (int i = 1; i < arr.length; i++) {
			int tmp = arr[i];
			int j = i - 1;
			for (; j >= 0 && arr[j] > tmp; j--) {
				arr[j + 1] = arr[j];
			}
			arr[++j] = tmp;
		}
	}

	private static void print(int[] arr) {
		for (int i : arr) {
			System.out.print(i + "  ");
		}
	}

}

 八、排序之希尔排序

package com.sort;

/**
 * @author tzp
 * @created 2020年6月22日 上午10:38:41 @类描述：希尔排序（增量排序）
 */
public class ShellSort {

	public static void main(String[] args) {
		int[] arr = { 8, 3, 6, 9, 2, 1, 3 };
		shellSort(arr);
		print(arr);
	}

	/**
	 * @author tzp
	 * @created 2020年6月22日 上午10:39:07
	 * @param param
	 * @return
	 * @方法描述：主要逻辑：在插入排序的基础上，添加了一个增量
	 */
	public static void shellSort(int[] arr) {
		for (int grp = arr.length / 2; grp > 0; grp /= 2) {// 遍历增量
			for (int i = grp; i < arr.length; i++) {
				int tmp = arr[i];
				int j = i - grp;
				for (; j >= 0 && arr[j] > tmp; j -= grp) {
					arr[j + grp] = arr[j];
				}
				arr[j + grp] = tmp;
			}
		}
	}

	private static void print(int[] arr) {
		for (int i : arr) {
			System.out.print(i + "  ");
		}
	}
}

 九、排序之冒泡排序

package com.sort;

/**
 * @author tzp
 * @created 2020年6月22日 上午11:22:52
 * @类描述：冒泡排序
 */
public class BubbleSort {

	public static void main(String[] args) {
		int[] arr = { 8, 3, 6, 9, 2, 1, 3 };
		bubbleSort(arr);
		print(arr);
	}

	/**
	 * @author tzp
	 * @created 2020年6月22日 上午11:23:08
	 * @param param
	 * @return
	 * @方法描述：主要逻辑：每趟遍历选出最大的元素移到一边
	 */
	public static void bubbleSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {// n-1趟
			for (int j = i + 1; j < arr.length; j++) {
				if(arr[i]>arr[j]) {//如果arr[i]大于arr[j]交换两个值（通过位运算的异或运算实现，不需要额外的临时变量）
					arr[i] = arr[i] ^ arr[j];
					arr[j] = arr[i] ^ arr[j];
					arr[i] = arr[i] ^ arr[j];
				}
			}
		}
	}

	private static void print(int[] arr) {
		for (int i : arr) {
			System.out.print(i + "  ");
		}
	}

}

 十、排序之堆排序

package com.sort;

/**
 * @author tzp
 * @created 2020年6月22日 下午2:59:01
 * @类描述：堆排序
 */
public class HeapSort {

	public static void main(String[] args) {
		int[] arr = { 8, 3, 6, 9, 2, 1, 3 };
		heapSort(arr);
		print(arr);
	}
	
	/**
	 * @author tzp
	 * @created 2020年6月22日 下午3:05:42
	 * @param param
	 * @return
	 * @方法描述：主要逻辑：二叉堆实现
	 */
	public static void heapSort(int[] arr) {
		for(int i = arr.length / 2 -1; i >= 0; i--)
			percDown(arr, i, arr.length);
		for(int i = arr.length - 1; i > 0; i--) {
			swapReferences(arr, 0, i);
			percDown(arr, 0, i);
		}
	}
	
	/**
	 * @author tzp
	 * @created 2020年6月22日 下午4:20:40
	 * @param param
	 * @return
	 * @方法描述：下滤
	 */
	public static void percDown(int[] arr, int i, int n) {
		int child = 0;
		int tmp = arr[i];
		for(;leftChild(i) < n; i = child) {
			child = leftChild(i);
			if(child != n - 1 && arr[child] < arr[child+1])
				child ++;
			if(tmp < arr[child]) {
				arr[i] = arr[child];
			}else {
				break;
			}
		}
		arr[i] = tmp;
	}
	
	/**
	 * @author tzp
	 * @created 2020年6月22日 下午4:20:02
	 * @param param
	 * @return
	 * @方法描述：获取左子树，二叉堆的结构性质
	 */
	public static int leftChild(int i) {
		return 2 * i + 1;
	}
	
	/**
	 * @author tzp
	 * @created 2020年6月22日 下午4:19:27
	 * @param param
	 * @return
	 * @方法描述：用位运算交换两个元素
	 */
	public static void swapReferences(int[] arr, int i, int n) {
		arr[i] = arr[i] ^ arr[n];
		arr[n] = arr[i] ^ arr[n];
		arr[i] = arr[i] ^ arr[n];
	}

	private static void print(int[] arr) {
		for (int i : arr) {
			System.out.print(i + "  ");
		}
	}
}

 十一、排序之归并排序

package com.sort;

/**
 * @author tzp
 * @created 2020年6月22日 下午4:23:04
 * @类描述：归并排序
 */
public class MergeSort {

	public static void main(String[] args) {
		int[] arr = { 8, 3, 6, 9, 2, 1, 3 };
		mergeSort(arr);
		print(arr);
	}

	/**
	 * @author tzp
	 * @created 2020年6月22日 下午4:24:20
	 * @param param
	 * @return
	 * @方法描述：主要逻辑：将两个已经排好序的数组进行合并
	 */
	public static void mergeSort(int[] arr) {
		int[] tmparr = new int[arr.length];
		mergeSort(arr, tmparr, 0, arr.length - 1);
	}

	/**
	 * @author tzp
	 * @created 2020年6月22日 下午5:24:04
	 * @param param
	 * @return
	 * @方法描述：递归的将两个已经排好序的数组合并
	 */
	public static void mergeSort(int[] arr, int[] tmparr, int left, int right) {
		if (left < right) {
			int center = (left + right) / 2;
			mergeSort(arr, tmparr, left, center);
			mergeSort(arr, tmparr, center + 1, right);
			merge(arr, tmparr, left, center + 1, right);
		}
	}

	/**
	 * @author tzp
	 * @created 2020年6月22日 下午5:25:34
	 * @param param
	 * @return
	 * @方法描述：合并两个已经排好序的数组
	 */
	public static void merge(int[] arr, int[] tmparr, int leftpos, int rightpos, int rightend) {
		int leftend = rightpos - 1;
		int tmppos = leftpos;
		int numele = rightend - leftpos + 1;
		while (leftpos <= leftend && rightpos <= rightend)
			if (arr[leftpos] <= arr[rightpos])
				tmparr[tmppos++] = arr[leftpos++];
			else
				tmparr[tmppos++] = arr[rightpos++];
		while (leftpos <= leftend)
			tmparr[tmppos++] = arr[leftpos++];
		while (rightpos <= rightend)
			tmparr[tmppos++] = arr[rightpos++];

		for (int i = 0; i < numele; i++, rightend--)
			arr[rightend] = tmparr[rightend];
	}

	private static void print(int[] arr) {
		for (int i : arr) {
			System.out.print(i + "  ");
		}
	}
}

 十二、排序之快速排序

package com.sort;

/**
 * @author tzp
 * @created 2020年6月22日 下午9:09:32
 * @类描述：快速排序
 */
public class QuickSort {

	public static void main(String[] args) {
		int[] arr = { 8, 3, 6, 9, 2, 1, 3 };
		quickSort(arr);
		print(arr);
	}

	/**
	 * @author tzp
	 * @created 2020年6月22日 下午9:10:27
	 * @param param
	 * @return
	 * @方法描述：主要逻辑：找到枢纽元（可以理解为中值）把小于枢纽元的元素集合、枢纽元、大于枢纽元的元素集合进行组装
	 */
	public static void quickSort(int[] arr) {
		quickSort(arr, 0, arr.length - 1);
	}

	/**
	 * @author tzp
	 * @created 2020年6月22日 下午9:15:33
	 * @param param
	 * @return
	 * @方法描述：递归的组合
	 */
	public static void quickSort(int[] arr, int left, int right) {
		if (left + 3 <= right) {
			int pivot = median(arr, left, right);
			int i = left, j = right - 1;
			for (;;) {
				while (arr[++i] < pivot) {
				}
				while (arr[--j] > pivot) {
				}
				if (i < j)
					swapReferences(arr, i, j);
				else
					break;
			}
			swapReferences(arr, i, right - 1);

			quickSort(arr, left, i - 1);
			quickSort(arr, i + 1, right);
		} else
			insertSort(arr, left, right);
	}

	/**
	 * @author tzp
	 * @created 2020年6月22日 下午9:15:53
	 * @param param
	 * @return
	 * @方法描述：数组元素小于一定数量时，直接使用插入排序
	 */
	public static void insertSort(int[] arr, int left, int right) {
		for (int p = left + 1; p <= right; p++) {
			int tmp = arr[p];
			int j;

			for (j = p; j > left && tmp < arr[j - 1]; j--)
				arr[j] = arr[j - 1];
			arr[j] = tmp;
		}
	}

	/**
	 * @author tzp
	 * @created 2020年6月22日 下午9:16:42
	 * @param param
	 * @return
	 * @方法描述：获取枢纽元（中值）
	 */
	public static int median(int[] arr, int left, int right) {
		int center = (left + right) / 2;
		if (arr[center] < arr[left])
			swapReferences(arr, left, center);
		if (arr[right] < arr[left])
			swapReferences(arr, left, right);
		if (arr[right] < arr[center])
			swapReferences(arr, center, right);
		swapReferences(arr, center, right - 1);
		return arr[right - 1];
	}

	/**
	 * @author tzp
	 * @created 2020年6月22日 下午4:19:27
	 * @param param
	 * @return
	 * @方法描述：用位运算交换两个元素
	 */
	public static void swapReferences(int[] arr, int i, int n) {
		int tmp = arr[i];
		arr[i] = arr[n];
		arr[n] = tmp;
	}

	private static void print(int[] arr) {
		for (int i : arr) {
			System.out.print(i + "  ");
		}
	}

}

 持续中~~~

马儿快跑儿
关注
专栏目录
按位与&的常见用法
JavaDad
05-15 514
判断奇偶性 public void judgeOdevity(int n) { if ((n & 1) == 1) { System.out.println(n + " is odd number."); } else if ((n & 1) == 0) { System.out.println(n + " is even number."); } } 判断是否包含 Java 中Modifier类便是这样设计的，是用来定义修饰符并且
Java 知识点杂记
Tattoo的博客
01-24 1086
这里写目录标题Java 中的 ==, equals 与 hashCode 的区别与联系String、StringBuffer、StringBuilder区别int 与 Integer区别Java 两种数据类型享元模式 Java 中的 ==, equals 与 hashCode 的区别与联系 == 分两种： 若是基本数据类型比较，是比较值， 若是引用类型，则比较的是他们在内存中存放的地址。 对象是放在堆中，栈中存放的对象的引用，所以==是对栈中的值进行比较，若返回 true ，代表变量的内存地址相等。
java知识点杂记
qq_34756106的博客
05-04 136
就是一些随笔，从手机便签中摞到CSDN 1. hashmap（key，value）类型中的hashcode和hashset中的hashcode实现不完全一样 1-1hashmap中的key通常是String，且多是用户根据业务自定义的，如name，因而hashcode函数针对的是String进行处理的，如从前到后对每个字符h=31*h+val[i]，这样每个不同字符串返回的hashcode必不一样（h是int型，万一溢出呢？取低位？因为取得是31奇素数所以即使溢出低32位也不会相同？） 1-2而h.
Java知识点杂记
qq_43293408的博客
03-09 204
JVM 的内存模型 JVM内存共分为虚拟机栈, 堆, 方法区,程序计数器, 本地方法栈五个部分 Java类加载机制 虚拟机把描述类的数据从class文件加载到内存中 ,并对数据进行校验,准备,解析和初始化,最终形成可以被虚拟机直接使用的Java类型的过程 具体加载加载过程 加载 加载时类加载的第一个过程 通过一个雷的全限定名获取该类的二进制流 将二进制流中的静态储存结构转化为方法区运行时的数据结构...
大数据知识点杂记
小道的博客
12-03 227
1、搜索引擎   Ⅰ、solr   Ⅱ、lucene 2、数据分析平台数据来源   Ⅰ、服务器日志（Nginx日志、apche日志、服务器系统日志…）   Ⅱ、业务日志(Log4j的日志、debug日志信息…)   ⅲ、用户行为数据   Ⅳ、第三方数据   ⅴ、网络爬虫数据   … 3、HBase协处理器的使用步骤   Ⅰ、继承BaseRegionServer实现内部处理方法   Ⅱ、打包成jar...
Java小知识点杂记
not_say的博客
11-20 153
JAVA杂记--个人笔记内部类方法内部类匿名内部类比较字符串和变量是否相等自定义可变参数方法更改器和访问器Collections.sort（可自定义，可用Lambda表达式）Java1.8 HashMapJava1.8 ConcurrentHashMapJava1.8 内存机制事务机制 #博客说明 此篇博客用来记录工作、学习过程中遇到的比较杂乱的小知识点。如果有侵权的情况请与我联系，我会及时删除或...
知识点杂记
m0_59111280的博客
01-20 177
1.+在输出语句中为连接符号（""所处位置不同所代表的含义不同） 例：int a=1; int b=2; public.out.println(""a=b); 输出
Java知识点----ThreadLocal杂记
站在搜素引擎上的巨人
10-30 206
ThreadLocal ThreadLocal实际是操作ThreadLocalMap的入口，只有传递参数的作用，并不会直接持有数据，真正存储数据的是其静态内部类ThreadLocalMap，ThreadLocal的属性包括当前线程和要保存的值，ThreadLocal只是提供set/get方法，通过ThreadLocal将Thread赋给ThreadLocalMap的key，想要保存的值赋给ThreadLocalMap的value，所以一个ThreadLocal=一个Thread=一个要保存的值=全局...
杂记知识点-String类
qq_43607964的博客
11-18 192
杂记知识点： 两天一题系列需要大量知识点支撑，故在没做出题目的某天刷书记录杂碎知识点。 今日知识点：字符串 字符串的定义 字符串的方法（重点） 字符串的定义： 1 构造字符串，需构造字符串对象，实例代码如下： String a = new String("study"); 2 先构造一个字符数组，后采用构造对象的方法，构建一个字符串 char[] c = {'s','t','u','d'...
java加密算法及常用知识学习杂记
10-31
5. **学习杂记**：学习加密算法不仅需要理解算法原理，还要熟悉Java提供的加密API。实践是提升技能的关键，通过编写示例代码，理解如何创建密钥、初始化Cipher对象、处理加密和解密过程。同时，了解加密过程中的常见...
面试杂记1
08-03
【Android项目构建流程】 在Android应用开发中，项目构建流程是至关...这些知识点涵盖了Android开发中的关键概念，对于理解和解答面试问题具有重要作用。理解并掌握它们有助于提升开发者的技术水平和项目实施能力。
计算机杂记
03-18
### 计算机基础知识知识点概览 #### 一、HTML（HyperText Markup Language）超文本标记语言 - **定义**：HTML 是一种用于创建网页的标准标记语言。它使用一系列的元素来构建页面结构和内容，如段落、链接、图片等。...
python定义空array_Python知识点杂记
weixin_39882948的博客
11-21 1913
1、divmod可以同时返回两个数的商和余数，如divmod(10, 3) = (3, 1)2、Python是可以设置全局精度的，用decimal模块，from decimal import getcontextgetcontext().prec = 4 #设置全局精度 小数点后保留4位有效位3、注意is与比较运算符“==”的区别is用于判断两个变量的引用是否为同一个对象，而==用于判断变量引用的...
Java企业面试题3
m0_74972727的博客
09-15 891
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
Arthas sysenv（查看JVM的环境变量）
最新发布
刘大猫
09-21 190
Arthas sysenv（查看JVM的环境变量）
JDK17新增语法特性
2201_76124988的博客
09-20 522
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 176
faiss版本 faiss-v1.7.4。
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 910
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
Java基础与Web技术概览：封装、继承与多态
"Java杂记.txt文件包含了丰富的Java编程基础知识和Web开发相关内容。该文档首先提到了学习Java编程时常用的在线资源，如菜鸟教程（适合初学者）、慕课平台（提供实践课程）和极客学院（针对职业发展）。文档详细介绍...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值