**์ฐธ์กฐํ ๋ฐ์ดํฐ ํ
- class, array, ๋ฌธ์์ด
))๋ฌธ์์ด ( String )
"๋ก ์์๋๋ ์ฌ๋ฌ ๋ฌธ์๋ค
String์ ๋ฌธ์์ด ์ ์ฅ์์ ์ ์ฅ๋๋ค
๋์ผํ ๋ฌธ์์ด์ ํ๋๋ง ์์ฑ๋๋ค.
String์ ์์์ฃผ์๋ฅผ ์ ์ฅํ๋ ๋ฐ์ดํฐ ํ java.lang.String ํด๋์ค์ด๋ค.
" " - ๋ฌธ์์ด ์์๋ java.lang.String์ method๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
-java.lang.String
๋ฌธ์์ด ์์์ ์์์ฃผ์๋ฅผ ์ ์ฅํ ์ ์๋ ํด๋์ค
์ฐธ์กฐํ ๋ฐ์ดํฐํ์ด์ง๋ง String๋ง ๊ธฐ๋ณธํ ํ์์ผ๋ก ์ฌ์ฉํ ์ ์๋ค.
new ๊ธฐ์ ํด์ผํจ. new๋ฅผ ๊ธฐ์ ํ์ง ์๊ณ , ์ฌ์ฉํ ์ ์๋ค.
์ฌ์ฉ๋ฒ)
-๋ฌธ๋ฒ์ ๋ฐ๋ผ ์์ฑ๋๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ค๋ฅด๋ค.
๊ธฐ๋ณธํ ํ์) - new ์ฌ์ฉํ์ง ์์
String str = "๋ฌธ์์ด"
stack์ ์ ์ฅ
์ฐธ์กฐํ ํ์) - new ์ฌ์ฉ.
String str = new String("๋ฌธ์์ด")
heap์ ์ ์ฅ
String ํด๋์ค ์ฌ์ฉํ๊ธฐ
1.์์ฑ => ์์ฑ์
String str = new String(); //๊ธฐ๋ณธ์์ฑ์ ์ฌ์ฉ
String str = new String("๋ฌธ์์ด"); // Overload๋ ์์ฑ์ ์ฌ์ฉ
2.๊ฐ์ฒด๊ฐ ์ ๊ณตํ๋ ์ผ ์ฌ์ฉ => method
๋ฌธ์์ด์ ๊ธธ์ด / str.length();
๋๋ฌธ์๋ก ๋ณํ / str.toUpperCase();
์๋ฌธ์๋ก ๋ณํ / str.toLowerCase();
๋ฌธ์์ด์์์ ํน์ ๋ฌธ์์ ์ธ๋ฑ์ค๋ฅผ ์ป๊ธฐ / str.indexOf("๋ฌธ์์ด");
๋ฌธ์์ด์์์ ํน์ ๋ฌธ์์ ์ธ๋ฑ์ค๋ฅผ์ป๊ธฐ(์ค๋ณต ๋ฌธ์์ค์ ๋ง์ง๋ง ๋ฌธ์) / str.lastIndexOf(“๋ฌธ์์ด”)
indexOf, lastIndexOf ๋ ์ฐพ์ ๋ฌธ์์ด์ด ์๋ ๊ฒฝ์ฐ -1์ด ๋์จ๋ค
ํน์ ์ธ๋ฑ์ค์ ํด๋นํ๋ ๋ฌธ์ ์ป๊ธฐ
“AbcdEF”;
‘c’=str.charAt( 2 )
์์๋ฌธ์์ด ์ป๊ธฐ
str.substring(์์์ธ๋ฑ์ค, ๋์ธ๋ฑ์ค+1)
๋ฌธ์์ด์ ์, ๋ค ๊ณต๋ฐฑ ์ ๊ฑฐ / str.trim()
๋ฌธ์์ด ์นํ
str=“AbcdE”;
replaceAll(“์ฐพ์ ๋ฌธ์์ด”,”์นํํ ๋ฌธ์์ด”)
๋ฌธ์์ด์ด ๊ฐ์์ง?
.equals(“๋น๊ตํ ๋ฌธ์์ด”);
ํน์ ๋ฌธ์์ด๋ก ์์ ํ๋ ์ง?
boolean=str.startsWith(“๋ฌธ์์ด”)
ํน์ ๋ฌธ์์ด๋ก ๋ ๋ฌ๋์ง?
boolean=str.endsWith(“๋ฌธ์์ด”);
ํน์ ๋ฌธ์์ด์ ํฌํจํ๋์ง?
boolean=str.contains(“๋ฌธ์์ด”)
๊ธฐ๋ณธํ ๋ฐ์ดํฐ ํ์ ๋ฌธ์์ด๋ก ์ ์ฅ
String.valueOf( ๊ธฐ๋ณธํ๋ฐ์ดํฐํ );
empty ํ์ธ (๋น์ด์๋?)
boolean =str.isEmpty();
------------------------------------
**array (๋ฐฐ์ด)
์ผ๊ด์ฒ๋ฆฌ ์ ์ฌ์ฉ
์ผ์ฐจ์, ์ด์ฐจ์, ์ผ์ฐจ์, ๊ฐ๋ณ๋ฐฐ์ด 4๊ฐ์ง ์ ๊ณต
๊ณ ์ ๊ธธ์ดํ. (๋ฐฉ(element)์ ๊ฐ์๊ฐ ์ค์ ๋๋ฉด ๋ณ๊ฒฝ๋์ง ์๋ ๊ฒ)
๋ชจ๋ ๋ฐ์ดํฐ ํ์ผ๋ก ๋ง๋ค ์ ์๋ค.
๋ฉ๋ชจ๋ฆฌ์ ๋์ผ ๋ฐ์ดํฐ ํ์ ์ฐ๊ฒฐํ์ฌ ์์ฑํ๋ ๊ฒ.
*์ผ์ฐจ์ ๋ฐฐ์ด
ํ๋์ ๋ฐฉ์ ์ด๋ก๋ง ๊ตฌ์ฑ๋ ๋ฐฐ์ด
๋ฐฉ์ ๊ฐ์๋ ๋ฐฐ์ด๋ช
.length๋ก ์ป์ ์ ์๋ค.
์ฐธ์กฐํ ๋ณ์์ ์ด๊ธฐํ(๊ธฐ๋ณธ๊ฐ) : null
์ฌ์ฉ๋ฒ)
1. ์ ์ธ)
๋ฐ์ดํฐํ[] ๋ฐฐ์ด๋ช
= null ; //๊ถ์ฅ (๋ฐ์ดํฐํ ๋ค์ชฝ์)
๋ฐ์ดํฐํ ๋ฐฐ์ด๋ช
[] = null ; //๊ถ์ฅํ์ง ์๋ ์ด์ : ๋ณ์๋ค์ด ๋ฐฐ์ด์ธ์ง ์๋์ง ํท๊ฐ๋ฆผ
int[] arr=null;
2. ์์ฑ)
๋ฐฐ์ด๋ช
=new ๋ฐ์ดํฐํ[๋ฐฉ์ ๊ฐ์];
arr = new int[4];
3. ๋ฐฉ ๊ฐ ํ ๋น)
๋ฐฐ์ด๋ช
[์ธ๋ฑ์ค]=๊ฐ;
arr[0]=12;
4. ๋ฐฉ ๊ฐ ์ป๊ธฐ)
//๋ฐฐ์ด๋ช
๋ง ์ฐ๋ฉด heap์ ๋ถ๋ฌ์์ ์๋ฏธ๊ฐ ์์
๋ฐฐ์ด๋ช
[์ธ๋ฑ์ค]
arr[0] << ์ด๋ ๊ฒ ๋ฐฉ์์ ๊ฐ์ ๋นผ์ผ์ํ //12์ถ๋ ฅ
*๋ฐฉ์ ๊ฐ์
arr.length ๋ฅผ ํตํด ๋ฐฉ์ ๊ฐ์๋ฅผ ๊ฐ์ ธ์ฌ ์ ์๋ค.
[] ๋ฐฐ์ด๊ธฐํธ
() ๋ฉ์๋๊ธฐํธ
{} ์์ญ