8:String类

String类

String类的特点: 字符串对象一旦被初始化就不会被改变。 

字符串是最常用的类型之一,所以为了使用方便java就给封装成了对象方便使用

 public static void stringDemo2() {  String s = "abc";//创建一个字符串对象在常量池中。     String s1 = new String("abc");//创建两个对象一个new一个字符串对象在堆内存和常量池中。 System.out.println(s==s1);//false 

System.out.println(s.equals(s1));

string类中的equals复写Object中的equals建立了string类自己的判断字符串对象是否相同的依据。

其实就是比较字符串内容。

 演示字符串定义的第一种方式,并明确字符串常量池的特点.

   池中没有就建立,池中有,直接用。

 private static void stringDemo1() {  String s = "abc";//"abc"存储在字符串常量池中。//	 s = "nba";  String s1 = "abc";  System.out.println(s==s1);//true//	 System.out.println("s="+s);/输出nab,s和s1是俩个字符串对象,s一开始指向了abc,又指向了nba,abc不变说的是这个意思}

常量池:

因为String类型一旦被初始化是不能被改变的,所以存放在常量池,存放在常量池中还有个很重要的原因:String s1 = “abs”;String s2=“abs”,这时s2并没有新建立一个对象,而是指向了s1这个对象。也就是说每当创建一个字符串时,并不是直接创建而是先到常量池中区找需要创建的对象是否存在,如果存在就不会再创建了。常量池中的元素是不会重复的,这也就是所谓的享元模式,例如当已经存在abs,这时需要创建ahk,这时常量池中只会增加两个字符h和k,然后在从常量池中抽出ahk对象。

特点:

1、String是一种特殊的数据类型,可创建对象。

2、通过String创建的对象分别可存在于常量池和堆内存中

3、String是一个final的类型,即不可被继承修改,一经初始化就终生不可改变。(要改变也是改变的引用)

4、常量池中的数据可共享,即两个引用变量可指向同一个字符串池中的字符串

5、Java中的任何对象都可写成字符串的形式。

6、既然String是对象,那就不得不说说null和“”的区别了。null是String对象指向为空,就是没有指向。而“”代表的是String对象指向的是一个空的字符串。

匿名对象

匿名对象就是表示没有名字的对象,那么什么叫对象的名字了?

一个字符串就是一个string的匿名对象


String类的构造器

将字节数组或者字符数组转成字符串可以通过String类的构造函数完成。 

 private static void stringConstructorDemo2() {   char[] arr = {'w','a','p','q','x'};//字符串转换成数组  String s = new String(arr,1,3);//字符的一部分转换成数组,从1角标取  System.out.println("s="+s); 输出s=apq }
 public static void stringConstructorDemo() {  String s = new String();//等效于String s = ""内容一样,地址不一样,都是指向空字符串; 但不等效String s = null;一般用String s = "",就行了,能被共享,当需要用构造器传数据,需要用new, byte[] arr = {97,66,67,68}; String s1 = new String(arr); //将数组变为字符,输出了abcd,编码转成了字节存储起来  System.out.println("s1="+s1);   } 

String类的方法(常见功能)

 按照面向对象的思想对字符串进行功能分类

字符串常见的操作方法:(String str = "hello java")

1、获取。 1.1 字符串中的包含的字符数,也就是字符串的长度。 int length():获取长度。str.length()//结果为10 1.2 根据位置获取位置上某个字符。 char charAt(int index)://charAt(1),结果是e 1.3 根据字符获取该字符在字符串中位置。//indexOf(’l‘)结果是2 int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。 int indexOf(int ch, int fromIndex) :从fromIndex指定位置开始,获取ch在字符串中出现的位置。 int indexOf(String str):返回的是str在字符串中第一次出现的位置。 int indexOf(String str, int fromIndex) :从fromIndex指定位置开始,获取str在字符串中出现的位置。 int lastIndexOf(int ch) :从后往前找,但是字符串中的角标是没有变的。

System.out.println("substring:"+s.substring(2,4));//cd

2、判断。 2.1 字符串中是否包含某一个子串。 boolean contains(str): 特殊之处:indexOf(str):可以索引str第一次出现位置,如果返回-1.表示该str不在字符串中存在。所以,也可以用于对指定判断是否包含。if(str.indexOf("aa")!=-1) 而且该方法即可以判断,有可以获取出现的位置。 2.2 字符中是否有内容。 boolean isEmpty(): 原理就是判断长度是否为0.  2.3 字符串是否是以指定内容开头。 boolean startsWith(str); 2.4 字符串是否是以指定内容结尾。 boolean endsWith(str); 2.5 判断字符串内容是否相同。复写了Object类中的equals方法。 boolean equals(str); 2.6 判断内容是否相同,并忽略大小写。 boolean equalsIgnoreCase();

3、转换。

3.1 将字符数组转成字符串。 构造函数:String(char[])  String(char[],offset,count):将字符数组中的一部分转成字符串。 静态方法: static String copyValueOf(char[]); static String copyValueOf(char[] data, int offset, int count)  static String valueOf(char[]): 3.2 将字符串转成字符数组。** char[] toCharArray(): 3.3 将字节数组转成字符串。 String(byte[]) String(byte[],offset,count):将字节数组中的一部分转成字符串。 3.4 将字符串转成字节数组。 byte[]  getBytes(): 3.5 将基本数据类型转成字符串。 static String valueOf(int) static String valueOf(double) //3+"";//String.valueOf(3); 特殊:字符串和字节数组在转换过程中,是可以指定编码表的。 4,替换 String replace(oldchar,newchar); 5,切割 String[] split(regex); 6,子串。获取字符串中的一部分。 String substring(begin); String substring(begin,end); 7,转换,去除空格,比较。 7.1 将字符串转成大写或则小写。 String toUpperCase(); String toLowerCase(); 7.2 将字符串两端的多个空格去除。 String trim(); 7.3 对两个字符串进行自然顺序的比较。 int compareTo(string);//大于返回正数,等于返回0,小于返回负数,且值为ASSII值之差。

 private static void stringMethodDemo_4() {  System.out.println("abc".compareTo("aqz")); }  stringMethodDemo_4(); }
public class StringObjectDemo {	public static void main(String[] args) {		// String s1 = "abc";		// String s2 = "abc";		// intern():对字符串池进行操作的		String s1 = new String("abc");		String s2 = s1.intern();		System.out.println(s1 == s2); // false	}}
public class StringDemo {      public static void main(String[] args) {          String str = "asdfghjaszxsa.java";          method_get(str);          print("------------------------------------------");          method_is(str);          print("------------------------------------------");          method_transform(str);          print("------------------------------------------");          method_replace(str);          print("------------------------------------------");          method_split(str);          print("------------------------------------------");          method_sub(str);          print("------------------------------------------");          method_change();      }        /*       * String获取方法 凡是获取的字符或者是字符串不存在,就返回-1       */      private static void method_get(String str) {          // 获取字符串的长度          int length = str.length();          print("length: " + length);            // 根据位置获取位置上的某个字符          char ch = str.charAt(1);          print("ch: " + ch);            // 根据字符获取该字符在字符串中的位置          int index = str.indexOf("index: " + 'a');// 获取该字符第一次出现的位置          print("index: " + index);            // int indexOf(int ch, int fromIndex) :从fromIndex指定位置开始,获取ch在字符串中出现的位置。          int indexf = str.indexOf('a', 2);          print("indexf: " + indexf);            // int indexOf(String str):返回的是str在字符串中第一次出现的位置。          int indexs = str.indexOf("as");          print("indexs: " + indexs);            // int indexOf(String str, int fromIndex)          // :从fromIndex指定位置开始,获取str在字符串中出现的位置。          int indexsf = str.indexOf("as", 3);          print("indexsf: " + indexsf);            // int lastIndexOf(int ch)          int indexlast = str.lastIndexOf('a');          print("indexlast: " + indexlast);      }        /*       * String中的判断       */      private static void method_is(String str) {          // 字符串中是否包含某一个子串          /*           * 特殊之处:indexOf(str):可以索引str第一次出现位置,如果返回-1.表示该str不在字符串中存在。           * 所以,也可以用于对指定判断是否包含。 if(str.indexOf("aa")!=-1) 而且该方法即可以判断,有可以获取出现的位置。           */          boolean iscon = str.contains("asd");          print("iscon: " + iscon);            // 字符中是否有内容。boolean isEmpty(): 原理就是判断长度是否为0.          boolean isemp = str.isEmpty();          print("isemp: " + isemp);            // 字符串是否是以指定内容开头。boolean startsWith(str);          boolean start = str.startsWith("asd");          boolean startoffset = str.startsWith("sd", 1);          print("start: " + start);          print("startoffset: " + startoffset);            // 字符串是否是以指定内容结尾。boolean endsWith(str);          boolean end = str.endsWith(".java");          print("end: " + end);            // 判断字符串内容是否相同。复写了Object类中的equals方法。boolean equals(str);          boolean equal = str.equals("asdfghjaszxsa.java");          print("equal: " + equal);            // 判断内容是否相同,并忽略大小写。boolean equalsIgnoreCase();          boolean equ = "AASD".equalsIgnoreCase("Aasd");          print("equ: " + equ);      }        /*       * 转换       */      private static void method_transform(String str) {          char[] chs = { 'a', 's', 'd', 'f', 'g' };          byte[] bts = { 'a', 's', 'd', 'f', 'g' };            // 将字符数组转成字符串          String trChStr = new String(chs);          String trChStrO = new String(chs, 1, 3);          print("trChStr: " + trChStr + "....trChStrO: " + trChStrO);          String copyvalueof = String.copyValueOf(chs);          print("copyvalueof: " + copyvalueof);            // 将字符串转成字符数组****          char[] tochar = str.toCharArray();          for (int x = 0; x < tochar.length; x++) {              print("char[" + x + "] = " + tochar[x]);          }            // 将字节数组转成字符串。          String trBtStr = new String(bts);          String trBtStrO = new String(bts, 1, 3);          print("trBtStr: " + trBtStr + "....trBtStrO: " + trBtStrO);            // 将字符串转成字节数组。byte[] getBytes():          // 特殊:字符串和字节数组在转换过程中,是可以指定编码表的。          byte[] getBts = str.getBytes();          for (int x = 0; x < getBts.length; x++) {              print("byte[" + x + "] = " + getBts[x]);          }            // 将基本数据类型转成字符串。static String valueOf(数据类型)          // 3+"";//String.valueOf(3);          String num = String.valueOf(2);          print("num: " + num);      }        /*       * 替换       */      private static void method_replace(String str) {          // 如果要替换的字符不存在,返回的还是原串。          String newStr = str.replace('a', 'm');// 替换掉所有的该字符          print(str);          print(newStr);            String newSt = str.replace("asd", "qqq");          print(str);          print(newSt);        }        /*       * 切割       */      private static void method_split(String str) {          // String[] split(regex);          String[] strs = str.split("s");          for (int x = 0; x < strs.length; x++) {              print("String[" + x + "] = " + strs[x]);          }      }        /*       * 获取字符串中的一部分       */      private static void method_sub(String str) {          print(str.substring(2));// 从指定位置开始到结尾。如果角标不存在,会出现字符串角标越界异常。          print(str.substring(2, 4));// 包含头,不包含尾。s.substring(0,s.length());      }        /*       * 转换,去除空格,比较。       */      private static void method_change() {          String s = "        Hello Java       ";          print(s.toLowerCase());// 转小写          print(s.toUpperCase());// 转大写          print(s.trim());// 去空格            // 对两个字符串进行自然顺序的比较          String s1 = "aaa";          String s2 = "aaa";          print(s1.compareTo(s2));// 大于返回正数,小于返回负数,相等返回0      }        private static void print(Object obj) {          System.out.println(obj);      }    

System.out.println("abc".concat("kk"));连接字符串,没什么用,直接连就行

System.out.println("abc"+"kk");

System.out.println(String.valueOf(4)+1);//41将基本数据类型变为字符串,再连接

System.out.println(""+4+1);和上一样

练习

 * 1,给定一个字符串数组。按照字典顺序进行从小到大的排序。 

 * {"nba","abc","cba","zz","qq","haha"}

 *

 * 思路:

 * 1,对数组排序。可以用选择,冒泡都行。

 * 3,问题:以前排的是整数,比较用的比较运算符,可是现在是字符串对象。

 *   字符串对象怎么比较呢?对象中提供了用于字符串对象比较的功能。

public class StringTest_1 {	public static void main(String[] args) {		String[] arr = { "nba", "abc", "cba", "zz", "qq", "haha" };		printArray(arr); // 原来的		sortString(arr);		printArray(arr); // 比较后的	}	public static void sortString(String[] arr) {		for (int i = 0; i < arr.length - 1; i++) {			for (int j = i + 1; j < arr.length; j++) {				if (arr[i].compareTo(arr[j]) > 0)// 字符串比较用compareTo方法					swap(arr, i, j);			}		}	}	private static void swap(String[] arr, int i, int j) {		String temp = arr[i];		arr[i] = arr[j];		arr[j] = temp;	}	public static void printArray(String[] arr) {		System.out.print("[");		for (int i = 0; i < arr.length; i++) {			if (i != arr.length - 1)				System.out.print(arr[i] + ", ");			else				System.out.println(arr[i] + "]");		}	}}

2,一个子串在整串中出现的次数。

 * "nbaernbatynbauinbaopnba"

 * 思路:

 * 1,要找的子串是否存在,如果存在获取其出现的位置。这个可以使用indexOf完成。

 * 2,如果找到了,那么就记录出现的位置并在剩余的字符串中继续查找该子串,

 * 而剩余字符串的起始位是出现位置+子串的长度.

 * 3,以此类推,通过循环完成查找,如果找不到就是-1,并对 每次找到用计数器记录。

public class StringTest_2 {	public static void main(String[] args) {		String str = "nbaernbatnbaynbauinbaopnba";		String key = "nba";		int count = getKeyStringCount_2(str, key);		System.out.println("count=" + count);	}	public static int getKeyStringCount_2(String str, String key) {		int count = 0;		int index = 0;		while ((index = str.indexOf(key, index)) != -1) {			index = index + key.length();			count++;		}		return count;	}	/**	 * 获取子串在整串中出现的次数。	 */	public static int getKeyStringCount(String str, String key) {		// 1,定义计数器。		int count = 0;		// 2,定义变量记录key出现的位置。		int index = 0;		while ((index = str.indexOf(key)) != -1) {			str = str.substring(index + key.length());//这个前面的str别不写			count++;		}		return count;	}}

 * 3,两个字符串中最大相同的子串。

 * "qwerabcdtyuiop"

 * "xcabcdvbn"

 *

 * 思路:

 * 1,既然取得是最大子串,先看短的那个字符串是否在长的那个字符串中。

 * 如果存在,短的那个字符串就是最大子串。

 * 2,如果不是呢,那么就将短的那个子串进行长度递减的方式去子串,去长串中判断是否存在。

 * 如果存在就已找到,就不用在找了。

public class StringTest_3 {	public static void main(String[] args) {		String s1 = "qwerabcdtyuiop";		String s2 = "xcabcdvbn";		String s = getMaxSubstring(s2, s1);		System.out.println("s=" + s);	}	/**	 * 获取最大子串	 * 	 * @param s1	 * @param s2	 * @return	 */	public static String getMaxSubstring(String s1, String s2) {		String max = null, min = null;		max = (s1.length() > s2.length()) ? s1 : s2;		min = max.equals(s1) ? s2 : s1;		System.out.println("max=" + max);		System.out.println("min=" + min);		for (int i = 0; i < min.length(); i++) {			for (int a = 0, b = min.length() - i; b != min.length() + 1; a++, b++) {				String sub = min.substring(a, b);				// System.out.println(sub);				if (max.contains(sub))					return sub;			}		}		return null;	}}

 * 4,模拟一个trim功能一致的方法。去除字符串两端的空白

 * 思路:

 * 1,定义两个变量。

 * 一个变量作为从头开始判断字符串空格的角标。不断++。

 * 一个变量作为从尾开始判断字符串空格的角标。不断--。

 * 2,判断到不是空格为止,取头尾之间的字符串即可。

public class StringTest_4 {	public static void main(String[] args) {		String s = "    ab   c     ";		s = myTrim(s);		System.out.println("-" + s + "-");	}	public static String myTrim(String s) {		int start = 0, end = s.length() - 1;		while (start <= end && s.charAt(start) == ' ') {			start++;		}		while (start <= end && s.charAt(end) == ' ') {			end--;		}		return s.substring(start, end + 1);	}}

练习五:将字符串反转。

 /*   思路:   1,将字符串变成数组。   2,对数组反转。   3,将数组变成字符串。   */    public class ReverseString {      public static void main(String[] args) {          String str = "shag klh";          String out = reverseString(str);          System.out.println(out);      }        /*       * 将字符串反转       */      private static String reverseString(String str) {          // 将字符串变成数组          char[] chs = str.toCharArray();            // 将数组反正,也就是收尾调换          reverseArray(chs);                    return new String(chs);      }        private static void reverseArray(char[] chs) {          char temp;          for (int start = 0, end = chs.length - 1; start < end; start++, end--) {              temp = chs[start];              chs[start] = chs[end];              chs[end] = temp;          }      }  

StringBuffer

   * StringBuffer:就是字符串缓冲区。

   * 用于存储数据的容器。

   * 特点:

   * 1,长度的可变的。

   * 2,可以存储不同类型数据。

   * 3,最终要通过toString方法变成字符串进行使用。

   * 4,可以对字符串进行修改。

Stringbuffer类:可以被修改的字符序列

   * 既然是一个容器对象。应该具备什么功能呢?

1、存储。 StringBuffer append():将指定数据作为参数添加到已有数据结尾处。不支持byte和char,需要对其进行转换才能操作。 StringBuffer insert(index,数据):可以将数据插入到指定index位置。 2、删除。 StringBuffer delete(start,end):删除缓冲区中的数据,包含start,不包含end。 StringBuffer deleteCharAt(index):删除指定位置的字符。 3、获取。 char charAt(int index)  int indexOf(String str)  int lastIndexOf(String str)  int length()  String substring(int start, int end)  4、修改。 StringBuffer replace(start,end,string); void setCharAt(int index, char ch) ; 5、反转。 StringBuffer reverse(); 6、将缓冲区中指定数据存储到指定字符数组中。 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)//第一个参数是说StringBuffer 从哪开始取值,第二个就是在哪结束啦,第三个参数是插入到哪个数据,第四个是说从数组中的哪个索引开始插入。

   *

   * 增删改查  C(create)U(update)R(read)D(delete)

   *

public class StringBufferDemo {	public static void main(String[] args) {		bufferMethodDemo_2();	}	private static void bufferMethodDemo_2() {		StringBuffer sb = new StringBuffer("abce");		// sb.delete(1, 3);//ae		// 清空缓冲区		// sb.delete(0,sb.length());		// sb = new StringBuffer();		// sb.replace(1, 3, "nba");		// sb.setCharAt(2, 'q');		// sb.setLength(10);		// System.out.println("sb:"+sb);		// System.out.println("len:"+sb.length());		System.out.println(sb.reverse());	}	private static void bufferMethodDemo_1() {		StringBuffer sb = new StringBuffer("abce");		// sb.append("xixi");		sb.insert(2, "qq");		System.out.println(sb.toString());	}	public static void bufferMethodDemo() {		// 创建缓冲区对象。		StringBuffer sb = new StringBuffer();		sb.append(4).append(false);// .append("haha");输出4falsehahh,连起来了		sb.insert(1, "haha");//4hahhfalse		// sb.append(true);//4hahhfalsetru,一个一个append和.append效果一样		System.out.println(sb);	}}

StringBuilder

   * jdk1.5以后出现了功能和StringBuffer一模一样的对象。就是StringBuilder

   * 不同的是:

   * StringBuffer是线程同步的。通常用于多线程。

   * StringBuilder是线程不同步的。通常用于单线程。 它的出现提高效率。

   *

   * jdk升级:

   * 1,简化书写。

   * 2,提高效率。

   * 3,增加安全性。

eg:

public class StringBuilderTest {	public static void main(String[] args) {		int[] arr = { 3, 1, 5, 3, 8 };		String s = arrayToString_2(arr);		System.out.println(s);	}	public static String arrayToString_2(int[] arr) {		StringBuilder sb = new StringBuilder();		sb.append("[");		for (int i = 0; i < arr.length; i++) {			if (i != arr.length - 1)				sb.append(arr[i] + ", ");			else				sb.append(arr[i] + "]");		}		return sb.toString();	}	/**	 * 	 * 将一个int数组变成字符串。	 */	public static String arrayToString(int[] arr) {		String str = "[";		for (int i = 0; i < arr.length; i++) {			if (i != arr.length - 1)				str += arr[i] + ", ";			else				str += arr[i] + "]";		}		return str;	}}
public class StringBuilderTest {	public static void main(String[] args) {		StringBuilder s1 = new StringBuilder("hello");		StringBuilder s2 = new StringBuilder("java");		show(s1, s2);		System.out.println(s1 + "......." + s2);	}	private static void show(StringBuilder s1, StringBuilder s2) {		s1.append(s2);		s1 = s2;//输出hellojava.......java
	}}

 基本数据类型对象包装类

   * 为了方便操作基本数据类型值,将其封装成了对象,在对象中定义了属性和行为丰富了该数据的操作。

   * 用于描述该对象的类就称为基本数据类型对象包装类。

   * byte Byte

   * short Short

   * int Integer

   * long Long

   * float Float

   * double Double

   * char Character

   * boolean Boolean

   * 该包装对象主要用基本类型和字符串之间的转换。

  •  基本类型--->字符串
  1. 基本类型数值+""
  2. 用String类中的静态方法valueOf(基本类型数值);
  3. 用Integer的静态方法valueO(基本类型数值);
  • 字符串--->基本类型
  1. 使用包装类中的静态方法   xxx parseXxx("xxx类型的字符串");*****

   * int parseInt("intstring");

   * long parseLong("longstring");

   * boolean parseBoolean("booleanstring");

   * 只有Character没有parse方法

     2.如果字符串被Integer进行对象的封装。

   * 可使用另一个非静态的方法,intValue();

   * 将一个Integer对象转成基本数据类型值。

System.out.println(Integer.MAX_VALUE);System.out.println(Integer.toBinaryString(-6)); int num = 4;Integer i = new Integer(5);int x = Integer.parseInt("123");System.out.println(Integer.parseInt("123")+1); Integer i = new Integer("123");
System.out.println(i.intValue());
  1. Integer a = new Integer("89"); Integer b = new Integer(89); System.out.println(a==b);//flase System.out.println(a.equals(b));//ture// System.out.println(3>3); System.out.println(a.compareTo(b));//0,内容相同,地址不同

  * 整数具备不同的进制体现。

   *

   * 十进制-->其他进制。

   * toBinaryString

   * toOctalString

   * toHexString

   *

   * 其他进制-->十进制。

   * parseInt("string",radix)

   *

  十进制-->其他进制。

  System.out.println(Integer.toBinaryString(60));   System.out.println(Integer.toOctalString(60));  System.out.println(Integer.toHexString(60));//	 System.out.println(Integer.toString(60,16));

其他进制-->十进制。

class IntegerDemo   {      public static void sop(String str)      {          System.out.println(str);      }            public static void main(String[] args)       {          //整数类型的最大值。          //sop("int max :"+Integer.MAX_VALUE);    //      将一个字符串转成整数。            int num = Integer.parseInt("123");//必须传入数字格式的字符串。          //long x = Long.parseLong("123");    //      sop("num="+(num+4));    //      sop(Integer.toBinaryString(-6));  //      sop(Integer.toHexString(60));            int x = Integer.parseInt("3c",16);  //后面传入前面是什么进制的          sop("x="+x);

自动装箱拆箱

class IntegerDemo1   {      public static void main(String[] args)       {            //      Integer x = new Integer(4);            Integer x = 4;//自动装箱。//new Integer(4)            x = x/* x.intValue() */ + 2;//x+2:x 进行自动拆箱。变成成了int类型。和2进行加法运算                      //再将和进行装箱赋给x            Integer m = 128;          Integer n = 128;            sop("m==n:"+(m==n));//结果为false            Integer a = 127;          Integer b = 127;            sop("a==b:"+(a==b));//结果为true。因为a和b指向了同一个Integer对象           //因为当数值在byte范围内容,对于新特性,如果该数值已经存在,则不会在开辟新的空间      }        public static void method()      {          Integer x = new Integer("123");            Integer y = new Integer(123);            sop("x==y:"+(x==y));          sop("x.equals(y):"+x.equals(y));      }  

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Java帮帮-微信公众号-技术文章全总结

Java基础(01)-15总结对象数组,集合Collection,集合List

1:对象数组(掌握) (1)数组既可以存储基本数据类型,也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。 (2)案例: 用数组存储5个学生对象...

4506
来自专栏CDA数据分析师

一文读懂如何用 Python 实现6种排序算法

总结了一下常见集中排序的算法 ? 归并排序 归并排序也称合并排序,是分治法的典型应用。分治思想是将每个问题分解成个个小问题,将每个小问题解决,然后合并。 具体...

2119
来自专栏程序员互动联盟

【编程基础】c printf知多少

printf()函数是格式输出函数,请求printf()打印变量的指令取决与变量的类型.例如,在打印整数是使用%d符号,在打印字符是用%c 符号.这些符号被称为...

3395
来自专栏ImportSource

一分钟告诉你java final 关键字运行原理

final关键字究竟是怎么运行的? 这是一个非常有趣的问题, import java.util.ArrayList; import java.util.List...

3768
来自专栏CDA数据分析师

一文读懂如何用 Python 实现6种排序算法

总结了一下常见集中排序的算法 ? 归并排序 归并排序也称合并排序,是分治法的典型应用。分治思想是将每个问题分解成个个小问题,将每个小问题解决,然后合并。 具体的...

21610
来自专栏郭耀华‘s Blog

Java Arrays工具类的使用

Arrays 类 java.util.Arrays类能方便地操作数组,它提供的所有方法都是静态的。具有以下功能: 给数组赋值:通过fill方法。 对数组...

3368
来自专栏乐百川的学习频道

Golang学习笔记 数据类型和变量

数据类型 先来介绍一下Golang的数据类型。 布尔型 bool类型代表逻辑值,有真值true和假值false两种取值。 整数类型 整数类型有如下几种,这些整数...

2028
来自专栏一直在跳坑然后爬坑

Kotlin之“AbstractMutableList”

打印结果分别为 prefix1:2:3:4:5:6postfix prefix1:2:3:truncatedpostfix

1632
来自专栏LhWorld哥陪你聊算法

【Scala篇】--Scala中集合数组,list,set,map,元祖

备注:数组方法 1     def apply( x: T, xs: T* ): Array[T] 创建指定对象 T 的数组, T 的值可以是 Unit, Do...

4721
来自专栏Clive的技术分享

PHP常用array函数

函数名 函数作用 array_chunk 数组分割 array_column 获取数组的某一列 array_combine 两个数组分别...

3666

扫码关注云+社区

领取腾讯云代金券