국비지원 JAVA(자바) 프로그래밍 (제네릭,제네릭스,람다,람다식)

제네릭/제네릭스

제네릭 사용이유↓

-타입체크기능 떄문에 사용(정수를 넣을지, 실수를 넣을지)

-그래서 형변환이 필요없어짐

package 제네릭;

public class NoGeneric {

	Object[] v; // Object는 최상위, class도 들어갈수있음 그리고 String, int 등 여러가지를 넣을 수 있음

	void set(Object[] n) { // set 같은 경우는 객체를 전달하게 됨 받은 객체를 v에다가 저장
		v = n;
	}

	Object[] get() { // 저장된 v를 리턴시켜줌
		return v;
	}

	void print() {
		for (Object o : v) {
			System.out.print(o + " ");
		}
	}
}

package 제네릭;

public class Sample01 {

	public static void main(String[] args) {

		NoGeneric nogen = new NoGeneric(); // nogen 이라는 것에 저장
		String[] ss = { "홍길동", "이순신", "김유신" };

		nogen.set(ss); // 배열방에있는 것을 믈래스에 있는 n으로 보내는 작업
		nogen.print(); // v안에 모든 데이터가 들어있는 상태에서 향상된 포문 돌려서 v에 대한 데이터가 o에 저장되면서 하나하나 출력된 것임

		Object[] objs = nogen.get(); // get메서드(return시켜줌)를 objs에 넣어줌

		for (Object o : objs) {
			String s= (String)o; 		// 형변환이 왜 필요한지? 
			System.out.print(s + " ");	// 형변환 했던거 , object로 전달받은것을 다시 string으로  넣으면 문제가 생겨서 형변환을 시켜서 쑤셔 넣은것임 s는 object가 아니라 문자열
		// 위에 s와 o가 다름
			System.out.print(o + " "); //형변환 안했던거 , 자료형 자체가 object로 구성, object는 연산이 안됨 

		}

 

---

package 제네릭;

public class Member {

	private String name;
	private String id;
	private String password;
	private int age;
	
	@Override
	public String toString() {
		return "Member [name=" + name + ", id=" + id + ", password=" + password + ", age=" + age + "]";
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	
	
}

package 제네릭;

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


public class Sample02 {

	public static void main(String[] args) {

	List<Member> list = new ArrayList<>();		// member전체클래스객체를 넣을거야라고 제네릭 설정
	
	Member mem1 =new Member();
	
	mem1.setName("홍길동");
	mem1.setId("aaa");
	mem1.setPassword("aa11");
	mem1.setAge(20);
	
	System.out.println(mem1);
	
	Member mem2 =new Member();

	mem2.setName("이순신");
	mem2.setId("bbb");
	mem2.setPassword("bb22");
	mem2.setAge(30);
	
	System.out.println(mem2);
	
	
	Member mem3 =new Member();

	mem3.setName("김유신");
	mem3.setId("ccc");
	mem3.setPassword("cc22");
	mem3.setAge(40);
	
	System.out.println(mem3);
	 
	list.add(mem1);
	list.add(mem2);
	list.add(mem3);
	
	for (int i = 0; i <list.size(); i++) { 			//length가 아니라 list.size();써야함!!
		
		System.out.println("이름:"+list.get(i).getName() ); 	// Member로 제네릭 
		System.out.println("아이디:"+list.get(i).getId() ); 	// Member로 제네릭 
		System.out.println("비밀번호:"+list.get(i).getPassword()); 	// Member로 제네릭 
		System.out.println("나이:"+list.get(i).getAge() ); 	// Member로 제네릭 
		
		}
	}
}

---

제네릭 이어서

package 제네릭;

/** 제네릭 2개 입력 **/
public class Generic2<K, V> {
   
   /** 아직 자료형 타입이 뭐가 될지 정해지지 않음 **/
   //문자열이 될지 문자가 될지 인수가 될지 실수가 될지 아직 미정
   K name; //name 변수 하나
   V id; //id 변수 하나
   
   /**Main에서 값을 받아오는 작업 set**/
   void set(K name, V id) { //값을 가져온다.
      this.name = name;
      this.id = id;
   }
   
   /** 가져온 값을 다시 보내주는 작업 get **/
   K getName() {
      return name;
   }
   
   V getId() {
      return id;
   }

}

package 제네릭;

public class Sample03 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	Generic2<String, Integer> gen = new Generic2<>(); // 스트링, 인티저로 제네릭설정!! 
	
	gen.set("문자열", 10);
	
	System.out.println("이름:"+gen.getName());
	System.out.println("아이디:"+gen.getId());
	
	
	}

}

---

package 제네릭;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.omg.CosNaming.NamingContextExtPackage.AddressHelper;

public class Main {

   public static void main(String[] args) {
      
      /**제네릭<Map>**/
      
      //list 내부에다가 Map을 넣어서 사용하는 경우
      //ArrayList() 내부에는 Map을 넣어서 처리할 수 있게 된다
      //Map 안에<키값과 벨류값>
      //list 객체에는 Map<문자열, 오브젝트>를 담고있다.
      List<Map<String, Object>> list = new ArrayList<>();
      
      //Map을 List에 넣어서 사용하기 위해서는 아래 Map에도 위와 똑같이 <String, Object> <-- 키와 벨류 값을 넣어줘야 된다.
      //HashMap에도 <> 이걸 붙여줘야 된다.
      //Map에는 순서가 없음
      Map<String, Object> hm = new HashMap<>();
      
      //put을 이용해 hm 객체에 아래 키값과 벨류 값을 저장한다.
      //put == 저장
      hm.put("name", "홍길동");
      hm.put("id", "hong");
      hm.put("age", 20);
      
      
      //list에 위에서 만든 Map을 추가해서 넣을 것
      list.add(hm);
      
      hm = new HashMap<>();
      
      hm.put("name", "이순신");
      hm.put("id", "lee");
      hm.put("age", 40);
   
      list.add(hm);
      
      hm = new HashMap<>();
      
      hm.put("name", "김유신");
      hm.put("id", "kim");
      hm.put("age", 50);
   
      list.add(hm);
   
      for (int i = 0; i <list.size(); i++) {
    	  System.out.println("이름:"+list.get(i).get("name"));	// 첫번쨰  get이 실행되고(list를 뽑아내고) 뒤에 get(map안에 있는 값)이 실행됨
    	  System.out.println("id:"+list.get(i).get("id"));		// list먼저 뽑고 map안에있는 키를 뽑아내서 이순신을 만듦. 바로 밸류를 뽑으면 안나옴 
    	  System.out.println("나이:"+list.get(i).get("age"));	
		
      }
   }
}

---

<?> : 모든 자료형 가능 

<? super Object?> : Object의 부모클래스 자료형을 참조 가능 

<? extents Object : Object의 자식 클래스 자료형을 참조 가능

package 제네릭;

public class Gen1 {

	String name= "Gen1";
	
	String getName() {
	return name;
	}
}

package 제네릭;

public class Gen2 extends Gen1 {

	String name= "Gen2";
	
	String getName() {
	return name;
	}
}

package 제네릭;

public class Gen3 extends Gen2 {

	String name= "Gen3";
	
	String getName() {
	return name;
	}
}

package 제네릭;

public class Gen4<T> {
   T obj;
   
   Gen4(T obj){
      this.obj = obj;
   }

   void set(T obj) {
      this.obj=obj;
   }
   T get() {
      return obj;
   }
}

package 제네릭;

public class Main2 {

	public static void main(String[] args) {

		Gen3 g3= new Gen3();
	
		Gen4<?super Gen2> g2 = new Gen4<Gen1>(g3); // super를 쓰면 부모클래스를 받아쓸 수 있음! 
//		Gen2 t1 = g2.get(); 실행이 안되는 이유? -> 
	}

}

여기의 흐름을 설명하시오..

Gen2 t1 = g2.get(); 실행이 안되는 이유? -> 

 

Gen4<?super Gen2> g2 = new Gen4<Gen1>(g3); // <?super를 쓰면 부모클래스를 받아쓸 수 있음! 

 

Gen4<? extends Gen2> g4 = new Gen4<Gen3>(g3);// <? extents Object : Object의 자식 클래스 자료형을 참조 가능

 

-> 둘이 실행되는 과정과 차이를 설명하시오. 흐름필요없다는데.... 

저렇게 사용할수 있는것들... 고정도만 구문해서 봐두시면 나을거같습니다..

 

다형성 개념 다시..

---

---

---

람다식- 익명 함수(메서드라고 생각해도됨) 

 

람다식을 쓰는 이유,장점 :

 

-> 추상메서드가 만들어져있어야함 (단 ,2개는 안됨)

클래스 내부-> 메서드

클래스 외부-> 함수 

람다식쓰는 법 인터페이스적고, 변수 적고 , 이퀄한다음 (매개변수)-> { 구현할것 (ex출력문같은거}; (마지막에 세미콜론 꼭 찍기!!!)

인터페이스-> 추상메서드 

 

람다식 익명함수

람다식 = () -> { };

f.apply(s);   // 람다식 호출하는 메서드

 

package 람다;

@FunctionalInterface
public interface Lamda1 {
	int add(int a,int b);
}

package 람다;

public class Main1 {

	public static void main(String[] args) {

	Lamda1 l=(int a, int b)-> a+b;						//Lamda1 l= 람다식(화살표함수) 
	
	System.out.println(l.add(10, 20));
	
	}

}

 

package 람다;

public interface Lamda2 {
	void print();
}

package 람다;

public class Main2 {

	public static void main(String[] args) {

			Lamda2 l =  () -> {
				String str = "메서드 실행";
				System.out.println(str);
		}; 
			l.print();
	}

}

---

Runnable (스레드,쓰레드)

package 람다;

public class Main3 {

	public static void main(String[] args) {

		System.out.println("시작");
		Runnable run = () -> {
			for (int i = 0; i < 10; i++) {
				System.out.print("첫번째: " + i);
			}
		};

		Runnable run2 = () -> {
			for (int i = 0; i < 10; i++) {
				System.out.print("두번째: " + i);
			}
		};
		
		Thread t = new Thread(run);
		Thread t2 = new Thread(run2);
		
		t.start();
		t2.start();
		
		System.out.println("종료");
	}
}

결과값이 이렇게 도출됨.

---

책 423p 참고하기 

 

Consumer<T> void accpet(T t)

 

IntConsumer   void accept(int i)

package 람다;

import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.DoubleConsumer;
import java.util.function.ObjIntConsumer;

public class Main8 {

	public static void main(String[] args) {

		Consumer<String> c1 = (name) -> {
			System.out.println("이름: "+ name);
		};
		
		c1.accept("홍길동");
		BiConsumer<String, String> c2 = (ln,fn) -> {
			System.out.println("첫번째: "+ln+"두번쨰: "+fn);
		};
		c2.accept("김" , "상");
	
		DoubleConsumer c3= (s) -> {
			System.out.println("입력받은 실수: "+s);
		};
		c3.accept(80);
	
		ObjIntConsumer<String> c4 = (a,b)-> {
			System.out.println("첫번째 obj "+a+"두번째int "+b);
		};
		c4.accept("김상훈", 100);
	}
}

결과값 

---

람다람다

 

package 람다;

import java.util.function.BooleanSupplier;
import java.util.function.IntSupplier;
import java.util.function.Supplier;

public class Main9 {

	public static void main(String[] args) {

		Supplier<String> s1 = () -> "홍길동";
	
		System.out.println(s1.get());
	
		IntSupplier s2 = ()->5;
		System.out.println(s2.getAsInt());
	
		BooleanSupplier s3 = ()-> true;
		System.out.println(s3.getAsBoolean());
	
	}
}

---

---

또람다// 배열이용!! 

package 람다;

public class Student {

	String name;
	int age;
	int math;
	String major;

	public Student(String name, int age, int math, String major) {
		this.name = name;
		this.age = age;
		this.math = math;
		this.major = major;
	}

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}

	public int getMath() {
		return math;
	}

	public String getMajor() {
		return major;
	}

}

 

 

package 람다;

import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;

public class Main10 {

	static Student[] List = { new Student("홍길동", 90, 80, "컴공"), new Student("이슨신", 95, 70, "컴공") }; // 객체배열

	public static void main(String[] args) {
		System.out.println("수학 점수 평균:");
		printAvg(t -> t.getMath());

		System.out.println("수학");
		printTot(t -> t.getMath());
	}

	static void printTot(ToIntFunction<Student> f) {
		int sum = 0;
		for (Student s : List) {
			sum += f.applyAsInt(s);
		}
		System.out.println("합계: " + sum);

	}

	static void printAvg(ToDoubleFunction<Student> f) {

		double sum = 0;
		for (Student s : List) {
			sum += f.applyAsDouble(s);
		}
		System.out.println(sum / List.length);
	}

}

 

 

람다식 이해하기! f값이 어디서 왔는가? 

---

---

operator