java字元串重復

A. 判斷字元串中是否有重復字元java

統計字元串中每個字元的個數，有大於1的說明有重復

Stringstr="abcdaefgh";

Map<String,Integer>map=newHashMap<String,Integer>();
for(charch:str.getChars())
{
Stringss=String.valueOf(ch);

Integercount=map.get(ss);

if(count==null)

count=1;

map.put(ss,count);

}

for(Stringst:map.keys())
{
System.out.println(st+":"+map.get(st));

}

B. JAVA字元串中去重復字元串

importjava.util.ArrayList;
importjava.util.List;

publicclass${

publicstaticvoidmain(String[]args){
Stringstr="教練教練裁判裁判裁判運動員運動員";

List<String>data=newArrayList<String>();

for(inti=0;i<str.length();i++){
Strings=str.substring(i,i+1);
if(!data.contains(s)){
data.add(s);
}
}

Stringresult="";
for(Strings:data){
result+=s;
}
System.out.println(result);
}
}

教練裁判運動員

C. Java如何簡單地讓字元串重復

原生的語法沒有
//java 11以上才行
String str = "abc";
String repeated = str.repeat(3);
repeated.equals("abcabcabc");

不過自己寫一個函數就行了，大多數工具之所以用起來簡單就是因為別人幫你寫了庫

D. java如何去掉字元串中重復的字元

lz 你好

這個就是一個比較簡單的演算法題 , 你可以自己寫

但是用Java語言就不需要了 , Java自帶泛型相關的類 , 很有用

其中TreeSet集合能自動識別添加的是否重復 , 重復的將不會添加 , 很方便

以下是實現代碼:

importjava.util.List;
importjava.util.Scanner;

publicclassDeleteRepeated{
	privateStringstr;
	privateTreeSet<String>noReapted;//帶有String類型的TreeSet泛型

publicDeleteRepeated(){
	Scannerin=newScanner(System.in);
	
	System.out.println("輸入一個字元串:");
	str=in.nextLine();
	
	noReapted=newTreeSet();
}

//清楚重復的數據
publicvoidremoveRepeated(){
	for(inti=0;i<str.length();i++){
		noReapted.add(""+str.charAt(i));
		//str.charAt(i)返回的是char型所以先加一個""空格,轉換成String型
		//TreeSet泛型能保證重復的不加入,而且有序
	}
	
	str="";
	
	for(Stringindex:noReapted){
		str+=index;
	}
	
	//輸出
	System.out.println(str);
}

publicstaticvoidmain(String[]args){
	DeleteRepeateddr=newDeleteRepeated();
	
	dr.removeRepeated();
}
}

運行截圖:

希望能幫助你哈

E. java中有沒有將一個字元串重復N次功能類或方法

java字元串連接一般有三種方式：

1. 直接用+號連接。


2. 用StringBuilder類。


3. 用StringBuffer類。

三種字元串連接的比較:
StringBuffer是線程安全的； StringBuilder不是線程安全的，但性能稍好一些，在不需要線程安全的字元串連接，盡量使用StringBuilder。（大部分情況下都不需要線程安全）jdk1.5的編譯器也是把+號編譯成StringBuilder來連接字元串的。 +號比想像中的智能，通過反編譯發現，在某些情況下可以放心的使用+號連接字元串。


1、對於很長的字元串可以分開用+號連接，不會影響性能。
如： Strings="aa"+"bb";
編譯器會自動處理成： Strings="aabb";


2、一條語句中，可以放心使用+號連接，不會影響性能。
如： Stringa="a"+"a"; Strings="a"+"b"+a+"c"+5+"d";
編譯器自動處理成：
Stringa="aa";
Strings=newStringBuilder("ab").append(a).append("c").append(5).append("d").toString();

F. 編寫一個java程序，接收用戶輸入的一行字元串，然後將輸入的字元串重復輸出3行，急求

接收用戶輸入用到Scanner類，將接收的字元串重復3次，用for循環
public class PrintString(){
public static void main(String args[]){
java.util.Scanner sc=new java.util.Scanner(System.in);
System.out.println("請輸入字元串");
String string=sc.nextLine();
for(int i=0;i<3;i++){
System.out.println(string);
}
}
}

G. java 用遞歸在字元串中重復出現的字元中添加一個*

Java中方法的概念以及遞歸（漢諾塔問題）

文章目錄

• Java中方法的概念以及遞歸（漢諾塔問題）

• 1、遞歸的概念

• 2、遞歸的練習

• 1)、漢諾塔問題

• 2)、青蛙跳台階

• 3)、青蛙跳台階（進階）（遞歸->動態規劃）

• 1、重載所能解決的問題

• 1、方法的概念

• 2、實參形參的關系

• 一、方法的基本使用

• 二、方法的重載

• 三、遞歸的概念

一、方法的基本使用

1、方法的概念

Java語言中的「方法」（Method）在其他語言當中也可能被稱為「函數」（Function）。

對於一些復雜的代碼邏輯，如果希望重復使用這些代碼，並且做到「隨時任意使用」，那麼就可以將這些代碼放在一個大括弧「{}」當中，並且起一個名字。使用代碼的時候，直接找到名字調用即可。

方法存在的意義：

• 能夠使代碼模塊化，使代碼的結構更加清晰。

• 當重復使用一個功能（代碼）時，只需要寫出方法名進行調用，避免相同代碼重復累贅。

• 讓代碼更好理解更簡單。

接下來看方法的結構：

訪問修飾限定符：自由選擇，告訴編譯器如何調用該方法。定義了該方法的訪問類型。

**靜態static：**當調用的主函數是static時，被調用的函數需要為static的。例如：java中，main方法直接調用add方法。此時的add方法需要static修飾。

返回值類型：方法可能會返回值。return Value Type 是方法返回值的數據類型。有些方法執行所需的操作，但沒有返回值。在這種情況下，return Value Type 是關鍵字void。

參數類型：參數像是一個佔位符。當方法被調用時，傳遞值給參數。這個值被稱為實參或變數。參數列表是指方法的參數類型、順序和參數的個數。參數是可選的，方法可以不包含任何參數。

方法名（函數名）：是方法的實際名稱。方法名和參數表共同構成方法簽名。

方法體：方法體包含具體的語句，定義該方法的功能。

• public class Main { public static void main(String[] args) { int a = 10; int b = 20; int c = add(a, b); //在main方法中，直接調用其他方法，必須為static的方法 } public static int add(int num1, int num2) { return num1 + num2; }}



2、實參形參的關系

實參：在方法中，實際傳遞的數值就是實際參數。比如上面的main函數中， int c = add(a, b); 這里的a和b就是實際參數，稱為實參。

形參：在被調用的方法里，由實參傳遞過來的數值，就稱為形式參數。形參是實參的一份臨時拷貝。也就是說，main函數傳遞的a和b，與add方法中的a和b，雖然都是10和20（上面代碼中），但是二者並不是來自同一塊內存空間：如下圖所示：

二、方法的重載

1、重載所能解決的問題

在我們平常寫代碼中，少不了數據的加減乘除。也少不了對不同類型的數據進行四則運算。假設：我們就寫了上面的代碼（add方法），我們用浮點數（小數）調用add方法，會有什麼情況發生？

此時大家就會想，我重新寫一個double類型的方法不就行了嗎。

沒錯，就是再次寫一個double類型的add就行啦。在C語言中，我們寫的函數（方法），不能夠寫重命的。比如，我寫兩個add的函數。函數名就是叫add。一模一樣，在C語言中是不允許的。

但是在java中，這是可以。也就是這節所講的 方法重載。

根據形參的類型和形參的個數，去尋找被調用的方法。

上面的代碼，分別調用了add方法，雖然都叫add。但是形參類型不一樣。所以是兩個不同的方法。這就叫重載。

重載的規則

• 方法名相同

• 方法的參數不同。（形參類型不同，個數不同）

• 方法的返回值類型不影響重載

註：當方法的方法名相同，參數相同，但返回值類型不同的時候，這不構成重載。

三、遞歸的概念

1、遞歸的概念

一個方法在自己調用自己時，就稱為「遞歸」。

當一個大問題，是由若干個小問題，並且這些小問題的解決方法，都是一樣的。這樣的問題，很大可能就能用遞歸去解決。

遞歸相當於數學上的**「數學歸納法**」,有一個起始條件, 然後有一個遞推公式

例如,我們求N!

起始條件: N= 1的時候, N!為1. 這個起始條件相當於遞歸的結束條件.

遞歸公式:求N!,直接不好求,可以把問題轉換成N!=> N * (N-1)!

例如代碼：

• public class Main { public static void main(String[] args) { int n = 5; //求5的階乘 System.out.println(fact(n)); } public static int fact (int n) { if (n == 1) { //遞歸結束的條件 return 1; } return n * fact(n - 1); //例如5！ = 5 * 4！ -》 5 * 4 * 3！ ，一直遞歸到1的階乘，就結束 }}



2、遞歸的練習

1)、漢諾塔問題

漢諾塔游戲（7K7K小游戲鏈接）。在開始講解之前，大家還是先去玩一玩漢諾塔游戲，看看是什麼規則。更容易的理解下面的代碼。

牛客網OJ題鏈接

漢諾塔游戲規則：

現有三根柱子，我們分別叫left, mid,right。現在有3個圓盤left柱子上，3個圓盤的大小關系為：從上往下，圓盤越來越大。

每次只能取出一個圓盤，並且圓盤在取和放的時候，必須在這三根柱子上完成。不能取出來放到其他地方。

且，大的圓盤不能放到小的圓盤上。

問，怎麼移動圓盤，讓圓盤從left柱子，移動到right柱子上。

情況一：我們先從1個圓盤舉例說明， 我們直接從left柱，移動到right柱即可

情況二：2個圓盤的情況

情況三：3個圓盤的情況

這就是大致的思路：

• 先將N - 1層移動到mid柱子，給最下面那一層讓路。

• N - 1層移開之後，路就讓出來了。此時移動第N層圓盤即可。

• 此時第一步移動的 N- 1層圓盤 還在mid柱子上，現在就是從 mid柱子 移動到 right柱子上。

不要去深究每一步的細節，抓好大致的思路，確定好遞歸終止的條件。宏觀的去想這個問題，就能夠很好地抓到問題的本質。

• public class Main { public static void main(String[] args) { //漢諾塔 int n = 3; hanoiTower(n, "left", "right", "mid"); } public static void hanoiTower(int n, String from, String to, String mid) { if (n == 1) { System.out.println("move 1 from " + from + " to " + to); return; //記得返回，終止遞歸 } hanoiTower(n - 1, from, mid, to); //圖1 -> 圖2 System.out.println("move " + n + " from " + from + " to " + to); //圖2 -> 圖3 hanoiTower(n - 1, mid, to, from); //圖3 -> 圖4 }}



2)、青蛙跳台階

青蛙跳台階 OJ題鏈接

情況一：一步台階只能跳一次，就跳完了；1種

情況二：兩步台階題意是，青蛙一次可以跳一步台階，也可以跳兩步台階。所以情況二的跳法是2 種

情況三：三步台階

現在擺在我面前的問題就是。我要麼跳一步台階。我要麼跳兩步台階。

不對，是擺在青蛙面前的問題！！！口誤口誤！

假設1：青蛙跳一步台階後，還剩兩個台階沒跳。此時是不是又回到了兩層台階的決策問題（上文情況二）；

假設2：青蛙跳兩步台階後，還剩一個台階沒跳。此時是不是又回到了一層台階的決策問題（上文情況一）；

我們把這兩種情況的假設，結果加起來，就是三層台階的所有跳法了！！！

再往下，四層、五層……，推導的思路，不就展開了嘛

• public class Main { public static void main(String[] args) { int n = 3; //台階數 System.out.println(jumpFloor(n)); } public int jumpFloor(int target) { if (target == 1) { //情況一 return 1; } if (target == 2) { //情況二 return 2; } return jumpFloor(target - 1) + jumpFloor(target - 2); //情況三 }}



3)、青蛙跳台階（進階）（遞歸->動態規劃）

青蛙跳台階（進階）OJ鏈接

看完題目，各位有什麼感想？？？

是不是跟初級的，區別不是很大？遞歸終止的條件還是一步台階和兩步台階的情況。

情況一和情況二的情況，我們就不說了，跟上文初階的一模一樣。還是1種跳法和2種跳法；我們重點來看一下三層台階的情況。

情況三：三層台階

三層台階：也就是說青蛙一次可以跳到3層台階。彈跳力見漲啊！（注意：並不是說，青蛙就一次只能跳3層台階，題意是（1 ……n層中 ，每一層 它都可以一次跳過）。

假設青蛙一次最大跳三層：

假設一：青蛙第一次跳一層台階,還剩兩個台階沒跳 ->兩層台階的決策問題。

假設二：青蛙第一次跳兩層台階，還剩一個台階沒跳 ->一層台階的決策問題。

假設三：青蛙第一次跳三層台階，沒有台階跳了 ->0層台階的決策問題。

那如果是四層台階 五層台階 N層台階呢？ 那是不是有幾層，就有幾種假設情況？那就需要相加！！！來看這個題的代碼：

• public class Main { public static void main(String[] args) { int n = 3; //假設就是3層台階 System.out.println(frogJumpPlus(n)); } public static int frogJumpPlus(int n) { if (n == 1) { return 1; } if (n == 2) { return 2; } int res = 1; //當前，需要選擇一種的跳法 //此處的for循環，就是去嘗試，跳1步、2步、3步……一直跳到n層台階，將這些情況全部加起來，就是當前的結果 for (int i = 1; i < n; i++) { res += frogJumpPlus(n - i); //i控制台階數，每次循環，都減一步台階。去遞歸所有的台階 } return res; }}



上面的代碼，就是經典的遞歸方式，去解這個題。

其實，在台階數足夠大時，這樣的遞歸，會有很多的重復計算：比如：

計算5層台階時：

假設一：第一次跳一層台階，第二次跳一層台階。此時還剩三層台階。 ->三層台階決策問題。

假設二：第一次跳兩層台階，此時還剩下三層台階。 ->三層台階決策問題。

此時我們就發現了，上面兩種假設就會產生重復計算。我們此時就想，有沒有一種方法，讓我們只計算一次，就能解決重復計算的問題。

那就是加緩存，我們用一塊空間，來保存每次計算的結果，當我們需要的時候，直接從內存空間裡面拿就行。

暴力遞歸 -> 動態規劃：

• public class Main { public static void main(String[] args) { int n = 3; //假設就是3層台階 System.out.println(frogJumpPlus(n)); } public static int frogJumpPlus(int n) { if (n == 1) { return 1; } int[] dp = new int[n + 1]; dp[1] = 1; dp[2] = 2; for (int i = 3; i <= n; i++) { dp[i] = 1; //加上自己需要跳的這一步 for (int j = 1; j < i; j++) { dp[i] += dp[j]; //把前面所有數據，累加一遍，就是當前台階的跳法 } } return dp[n]; }}



對比兩種方法：

我們畫出前面幾組數據，就能找出規律：

可能你就會疑惑，我寫不出來這動態規劃。那可以先寫遞歸的版本。在遞歸的版本上去修改，加緩存。

具體是以什麼形式來緩存，還得看你的可變參數，例如這個題的可變參數就只有一個n，也就是台階數。那我們就開辟一維數組，就能解決。

那如果是兩個可變參數，那麼此時就可能需要二維數組來做緩存了！！！

總之，像這種考察遞歸的題目。我們都可以加緩存的形式。到底需不需要加緩存，我們就得看看，遞歸的時候，是否涉及了大量的重復計算。

最後考考大家，上面寫的動態規劃的版本，是否還可以優化呢？？？（提示一下： 兩層for循環，時間復雜度O（N2））

好啦，本期更新就到此結束了，我們下期見！！！



,https://blog.csdn.net/x0919/article/details/119279165

H. java如何去除字元串中重復的字元

lz 你好

這個就是一個比較簡單的演算法題 , 你可以自己寫

但是用Java語言就不需要了 , Java自帶泛型相關的類 , 很有用

其中TreeSet集合能自動識別添加的是否重復 , 重復的將不會添加 , 很方便

以下是實現代碼:

import java.util.List;
import java.util.Scanner;

public class DeleteRepeated {
private String str;
private TreeSet<String> noReapted;//帶有String類型的TreeSet泛型

public DeleteRepeated() {
Scanner in = new Scanner(System.in);

System.out.println ("輸入一個字元串:");
str = in.nextLine();

noReapted = new TreeSet();
}

//清楚重復的數據
public void removeRepeated(){
for (int i = 0; i < str.length(); i++){
noReapted.add(""+str.charAt(i));
//str.charAt(i)返回的是char型 所以先加一個""空格 , 轉換成String型
//TreeSet泛型能保證重復的不加入 , 而且有序
}

str = "";

for(String index:noReapted){
str += index;
}

//輸出
System.out.println (str);
}

public static void main(String[] args) {
DeleteRepeated dr = new DeleteRepeated();

dr.removeRepeated();
}
}